public static void SendGeometry(List <object> Geometry, List <string> Name)
{
int i = 0;
string paddedName = "";
foreach (var geom in Geometry)
{
if (Geometry.Count > 1 && Geometry.Count == Name.Count)
{
paddedName = Name[i];
}
else if (Geometry.Count == 1 && Name.Count == 1)
{
paddedName = Name[0];
}
else
{
int pad = Geometry.Count.ToString().Length;
paddedName = Name[0] + "_" + i.ToString().PadLeft(pad);
}
try
{
DMInterop.processGeometry(geom, paddedName, "");
}
catch (Exception e) { MGlobal.displayWarning(e.Message); }
i++;
}
}
public static Dictionary <string, List <object> > getParticles(string name, bool unitizeVelocity = false)
{
MDoubleArray pPos = new MDoubleArray();
MGlobal.executeCommand("getParticleAttr -at position -at velocity -array true " + name, pPos);
List <object> particlePos = new List <object>();
List <object> particleVec = new List <object>();
int numPart = 0;
var posAttr = DMInterop.getPlug(name, "position");
if (posAttr.isArray)
{
numPart = (int)posAttr.numElements;
particlePos = new List <object>(numPart);
particleVec = new List <object>(numPart);
for (uint i = 0; i < numPart; i += 3)
{
particlePos.Add(Point.ByCoordinates(posAttr[i].asDouble(), posAttr[i + 1].asDouble(), posAttr[i + 2].asDouble()));
}
}
return(new Dictionary <string, List <object> >
{
{ "Particles", particlePos },
{ "Velocity", particleVec }
});
}
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);
}
internal static Surface mNurbsSurfaceToDynamoSurfaceFromName(string dagName, string space)
{
MSpace.Space mspace = MSpace.Space.kWorld;
Enum.TryParse(space, out mspace);
MDagPath dagPath = DMInterop.getDagNode(dagName);
return(mNurbsSurfaceToDynamoSurfaceFromDag(dagPath, mspace));
}
internal static Curve CurveFromMfnNurbsCurveFromName(string dagName, string space)
{
var mspace = MSpace.Space.kWorld;
Enum.TryParse(space, out mspace);
var dagPath = DMInterop.getDagNode(dagName);
return(CurveFromMfnNurbsCurveFromDag(dagPath, mspace));
}
public static List <List <Curve> > getSmothMeshEdgesPerFace(MFnMesh mayaMesh, bool createInMaya = false)
{
MCommandResult ptcResult = new MCommandResult();
MCommandResult teResult = new MCommandResult();
int numPoly = mayaMesh.numPolygons;
List <List <Curve> > curveObjects = new List <List <Curve> >(numPoly);
MStringArray ptcResultStr = new MStringArray();
MStringArray teResultStr = new MStringArray();
MStringArray teResultStrFlat = new MStringArray();
List <Curve> tempCurveArray = null;
if (createInMaya)
{
}
else
{
for (int i = 0; i < numPoly; i++)
{
MGlobal.executeCommand($"polyListComponentConversion -te {mayaMesh.name}.f[{i}]", teResult);
teResult.getResult(teResultStr);
MGlobal.clearSelectionList();
foreach (var ters in teResultStr)
{
MGlobal.selectByName(ters, MGlobal.ListAdjustment.kAddToList);
}
MGlobal.executeCommand($"ls -sl -fl", teResult);
teResult.getResult(teResultStrFlat);
tempCurveArray = new List <Curve>((int)teResultStrFlat.length);
foreach (var e in teResultStrFlat)
{
MGlobal.executeCommand($"polyToCurve -name deleteMe11232204332AA -form 2 -degree 3 -conformToSmoothMeshPreview 1 {e}", ptcResult);
ptcResult.getResult(ptcResultStr);
tempCurveArray.Add(DMCurve.CurveFromMfnNurbsCurveFromName(ptcResultStr[0], MSpace.Space.kPostTransform.ToString()));
try
{
MGlobal.deleteNode(DMInterop.getDependNode(ptcResultStr[0]));
}
catch
{
MGlobal.displayWarning("getSmothMeshEdges: unable to delete temp object");
}
}
curveObjects.Add(tempCurveArray);
}
}
return(curveObjects);
}
internal static Mesh MTDMeshFromName(string dagName, string space)
{
MDagPath dagPath = DMInterop.getDagNode(dagName);
MSpace.Space mspace = MSpace.Space.kWorld;
Enum.TryParse(space, out mspace);
return(MTDMeshFromDag(dagPath, mspace));
}
public static MFnMesh GetMayaMesh(string dagName, string space)
{
MDagPath dagPath = DMInterop.getDagNode(dagName);
MSpace.Space mspace = MSpace.Space.kWorld;
Enum.TryParse(space, out mspace);
MFnMesh mayaMesh = new MFnMesh(dagPath);
return(mayaMesh);
}
public static MFnNurbsSurface GetMayaObject(string dagName, string space)
{
MDagPath dagPath = DMInterop.getDagNode(dagName);
MSpace.Space mspace = MSpace.Space.kWorld;
Enum.TryParse(space, out mspace);
MFnNurbsSurface mayaObject = new MFnNurbsSurface(dagPath);
return(mayaObject);
}
public static Point[] ConnectedVtx(this Mesh m, Point searchPoint)
{
int[] conectedVtxID = DMInterop.GetConnectedPointID(m, searchPoint);
List <Point> connectedVtx = new List <Point>(conectedVtxID.Length);
foreach (var id in conectedVtxID)
{
connectedVtx.Add(m.VertexPositions[id]);
}
return(connectedVtx.ToArray());
}
public static void SetRobotJointsRotations(double[] rotationVals, string[] jointNames = null)
{
string[] jName;
if (jointNames != null && jointNames.Length == 6)
{
jName = jointNames;
}
else
{
jName = new string[6] {
"J1", "J2", "J3", "J4", "J5", "J6"
};
}
if (rotationVals.Length != 6)
{
new WarningException("The roation values must contain exactly 6 values, one for each axis");
}
/*
* string melCmd =
* string.Format(
* "setAttr J1.rx {0}; setAttr J2.rz {1}; setAttr J3.rz {2}; setAttr J4.rx {3}; setAttr J5.rz {4}; setAttr J6.rx {5}; ",
* rotationVals[0], -rotationVals[1], -rotationVals[2], rotationVals[3], rotationVals[4], rotationVals[5]+90);
*
* MGlobal.executeCommand(melCmd);
*/
try
{
MPlug j1Plug = DMInterop.getPlug(jName[0], "rx");
j1Plug.setDouble(rotationVals[0] * 0.0174533);
MPlug j2Plug = DMInterop.getPlug(jName[1], "rz");
j2Plug.setDouble(-rotationVals[1] * 0.0174533);
MPlug j3Plug = DMInterop.getPlug(jName[2], "rz");
j3Plug.setDouble(-rotationVals[2] * 0.0174533);
MPlug j4Plug = DMInterop.getPlug(jName[3], "rx");
j4Plug.setDouble(rotationVals[3] * 0.0174533);
MPlug j5Plug = DMInterop.getPlug(jName[4], "rz");
j5Plug.setDouble(-rotationVals[4] * 0.0174533);
MPlug j6Plug = DMInterop.getPlug(jName[5], "rx");
j6Plug.setDouble(rotationVals[5] * 0.0174533);
}
catch (Exception e)
{
MGlobal.displayWarning(e.Message);
}
}
internal static CoordinateSystem mLocatorFromName(string dagName, string space)
{
MDagPath dagPath = DMInterop.getDagNode(dagName);
MSpace.Space mspace = MSpace.Space.kWorld;
Enum.TryParse(space, out mspace);
// MObject obj = DMInterop.getDependNode(dagName);
MMatrix worldPos = dagPath.inclusiveMatrix;
double x = worldPos[3, 0];
double y = worldPos[3, 1];
double z = worldPos[3, 2];
MEulerRotation rot = new MEulerRotation();
double xr = worldPos[3, 0];
double yr = worldPos[3, 1];
double zr = worldPos[3, 2];
//MFnTransform loc = new MFnTransform(dagShape.node);
//var vec = loc.transformation.getTranslation(mspace);
//return Point.ByCoordinates(vec.x, vec.y, vec.z); ;
CoordinateSystem cs;
if (MGlobal.isZAxisUp)
{
cs = CoordinateSystem.ByOrigin(x, y, z);
cs.Rotate(cs.Origin, Vector.XAxis(), x);
cs.Rotate(cs.Origin, Vector.YAxis(), y);
cs.Rotate(cs.Origin, Vector.ZAxis(), z);
return(cs);
}
else
{
cs = CoordinateSystem.ByOrigin(x, -z, y);
cs.Rotate(cs.Origin, Vector.XAxis(), x);
cs.Rotate(cs.Origin, Vector.YAxis(), y);
cs.Rotate(cs.Origin, Vector.ZAxis(), z);
return(cs);
}
}
public static List <int[]> GetFaceVertexIdx(string dagName, string space)
{
MDagPath dagPath = DMInterop.getDagNode(dagName);
MSpace.Space mspace = MSpace.Space.kWorld;
Enum.TryParse(space, out mspace);
MFnMesh mayaMesh = new MFnMesh(dagPath);
List <int[]> vtxIds = new List <int[]>(mayaMesh.numPolygons);
MIntArray ids = new MIntArray();
for (int i = 0; i < mayaMesh.numPolygons; i++)
{
mayaMesh.getPolygonVertices(i, ids);
vtxIds.Add(ids.ToArray());
}
return(vtxIds);
}
public static void SetPlugValue(string objectName, string plugName, object plugValue)
{
MPlug plug;
try
{
plug = DMInterop.getPlug(objectName, plugName);
}
catch (Exception e)
{
MGlobal.displayWarning($"plug not found: {e.Message}");
return;
}
if (plugValue is double)
{
plug.setDouble(Convert.ToDouble(plugValue));
}
else if (plugValue is int)
{
plug.setInt(Convert.ToInt32(plugValue));
}
else if (plugValue is Vector)
{
Vector vec = (Vector)plugValue;
var mVector = new MVector();
if (MGlobal.isYAxisUp)
{
mVector.x = vec.X;
mVector.y = vec.Z;
mVector.z = -vec.Y;
}
else
{
mVector.x = vec.X;
mVector.y = vec.Y;
mVector.z = vec.Z;
}
}
}
private void DeserializeNameList(string nameListString)
{
var splitNames = nameListString.Split(',');
if (splitNames.Length > 0)
{
SelectedItems = new Dictionary <string, DMSurface>(splitNames.Length);
foreach (var name in splitNames)
{
try
{
var itm = new DMSurface(DMInterop.getDagNode(name), space);
itm.Deleted += MObjOnDeleted;
itm.Changed += MObjOnChanged;
SelectedItems.Add(itm.dagName, itm);
}
catch
{
Warning($"Object {name} does not exist or is not valid");
}
}
}
}
public static Line[] Edges(this Mesh m)
{
int[] svtx, evtx;
return(DMInterop.GetMeshEdges(m, out svtx, out evtx));
}
public static void ToMaya(Surface SurfaceToSend, string name, string groupName)
{
NurbsSurface dynSurf;
try
{
dynSurf = SurfaceToSend.ToNurbsSurface();
}
catch (Exception)
{
dynSurf = null;
MGlobal.displayWarning("Surface has no nurbSurface form");
}
//MFnNurbsSurface updatedSurface;
MPointArray cvs = new MPointArray();
Point[][] ctrlPts = dynSurf.ControlPoints();
for (int i = 0; i < ctrlPts.Length; i++)
{
for (int j = 0; j < ctrlPts[i].Length; j++)
{
MPoint p = new MPoint();
if (MGlobal.isZAxisUp)
{
p.x = ctrlPts[i][j].X;
p.y = ctrlPts[i][j].Y;
p.z = ctrlPts[i][j].Z;
}
else
{
p.x = ctrlPts[i][j].X;
p.y = ctrlPts[i][j].Z;
p.z = -ctrlPts[i][j].Y;
}
cvs.Add(p);
}
}
MDoubleArray uknot = new MDoubleArray(dynSurf.UKnots());
uknot.RemoveAt(0);
uknot.RemoveAt(uknot.Count - 1);
MDoubleArray vknot = new MDoubleArray(dynSurf.VKnots());
vknot.RemoveAt(0);
vknot.RemoveAt(vknot.Count - 1);
MFnNurbsSurface.Form formU = MFnNurbsSurface.Form.kInvalid;
MFnNurbsSurface.Form formV = MFnNurbsSurface.Form.kInvalid;
if (dynSurf.IsPeriodicInU)
{
formU = MFnNurbsSurface.Form.kPeriodic;
}
else if (dynSurf.ClosedInU)
{
formU = MFnNurbsSurface.Form.kClosed;
}
else
{
formU = MFnNurbsSurface.Form.kOpen;
}
if (dynSurf.IsPeriodicInV)
{
formV = MFnNurbsSurface.Form.kPeriodic;
}
else if (dynSurf.ClosedInV)
{
formV = MFnNurbsSurface.Form.kClosed;
}
else
{
formV = MFnNurbsSurface.Form.kOpen;
}
MDagPath existingDagPath = null;
bool nodeExists = false;
//trims
//toDo: impement trims
Task checkNode = null;
try
{
checkNode = Task.Factory.StartNew(() => existingDagPath = DMInterop.getDagNode(name));
checkNode.Wait(500);
nodeExists = true;
}
catch (Exception)
{
nodeExists = false;
}
MObject obj;
if (nodeExists)
{
if (checkNode.IsCompleted)
{
MFnNurbsSurface existingSurface = new MFnNurbsSurface(existingDagPath);
MDGModifier mdgModifier = new MDGModifier();
// if (existingSurface.degreeU == dynSurf.DegreeU && existingSurface.degreeV== dynSurf.DegreeV && existingSurface.numCVsInU == ctrlPts.Length && existingSurface.numCVsInV == ctrlPts[0].Length )
//{
if (existingSurface.degreeU != dynSurf.DegreeU || existingSurface.degreeV != dynSurf.DegreeV || existingSurface.numCVsInU != ctrlPts.Length || existingSurface.numCVsInV != ctrlPts[0].Length)
{
//this is a hack to rebuild the surface. proper way is to make new surface and assign as input to aold surface
MGlobal.executeCommand(string.Format("rebuildSurface -du {0} -dv {1} -su {2} -sv {3} {4}", dynSurf.DegreeU, dynSurf.DegreeV, ctrlPts.Length - 3, ctrlPts[0].Length - 3, name));
}
// updatedSurface = existingSurface;
existingSurface.setCVs(cvs);
existingSurface.setKnotsInU(uknot, 0, (uint)existingSurface.numKnotsInU - 1);
existingSurface.setKnotsInV(vknot, 0, (uint)existingSurface.numKnotsInV - 1);
existingSurface.updateSurface();
// }
/*
* else
*
* {
* //get all the existing node types
* MFnDagNode dagNodeExist = new MFnDagNode(existingDagPath);
* MObject existSurfObj = existingDagPath.node;
* MFnDependencyNode depNodeExist = new MFnDependencyNode(existSurfObj);
*
*
* updatedSurface = new MFnNurbsSurface();
* var newSurfObj = dagNodeExist.duplicate();
* updatedSurface.isIntermediateObject = true;
*
* updatedSurface.create(cvs, uknot, vknot, (uint)dynSurf.DegreeU, (uint)dynSurf.DegreeV, formU, formV, dynSurf.IsRational, newSurfObj);
* MFnDependencyNode depNodeNew = new MFnDependencyNode(newSurfObj);
*
* MPlug outSurf = depNodeExist.findPlug("outputSurface");
* MPlug inSurf = depNodeNew.findPlug("inputSurface");
*
*
* mdgModifier.connect(outSurf, inSurf);
*
*
* }
*/
mdgModifier.doIt();
// MFnDependencyNode nodeFn = new MFnDagNode(mSurf);
//nodeFn.setName(name);
//MGlobal.executeCommand("sets -e -forceElement initialShadingGroup " + nodeFn.name);
}
}
else
{
if (checkNode.IsCompleted)
{
MFnNurbsSurface updatedSurface = new MFnNurbsSurface();
obj = updatedSurface.create(cvs, uknot, vknot, (uint)dynSurf.DegreeU, (uint)dynSurf.DegreeV, formU, formV, dynSurf.IsRational);
MFnDependencyNode nodeFn = new MFnDagNode(obj);
nodeFn.setName(name);
MGlobal.executeCommand("sets -e -forceElement initialShadingGroup " + nodeFn.name);
}
}
if (groupName != "")
{
bool groupExists = false;
try
{
DMInterop.getDagNode(groupName);
groupExists = true;
}
catch { }
if (groupExists)
{
MGlobal.executeCommand(string.Format("parent {0} {1}", groupName, name));
}
else
{
MGlobal.executeCommand(string.Format("group -n {0} {1}", groupName, name));
}
}
}
public static int[] ConnectedVtxID(this Mesh m, Point searchPoint)
{
return(DMInterop.GetConnectedPointID(m, searchPoint));
}
public static bool ToMayaOLD(Mesh MeshToSend, string name)
{
bool nodeExists = false;
MDagPath node = null;
Task checkNode = null;
Task mobjMesh = null;
try
{
checkNode = Task.Factory.StartNew(() => node = DMInterop.getDagNode(name));
checkNode.Wait(500);
nodeExists = true;
}
catch (Exception)
{
nodeExists = false;
}
MFnMesh mfnMesh;
if (nodeExists)
{
mfnMesh = new MFnMesh(node);
}
else
{
mfnMesh = new MFnMesh();
}
//unpack geom
int numVert = MeshToSend.VertexPositions.Length;
int numPoly = MeshToSend.FaceIndices.Length;
MIntArray faceCnx = new MIntArray();
MFloatPointArray verticies = new MFloatPointArray();
MIntArray faceVtxCt = new MIntArray();
MFloatPoint vtxToAdd = new MFloatPoint();
foreach (var vtx in MeshToSend.VertexPositions)
{
if (MGlobal.isZAxisUp)
{
vtxToAdd.x = (float)vtx.X;
vtxToAdd.y = (float)vtx.Y;
vtxToAdd.z = (float)vtx.Z;
}
else
{
vtxToAdd.x = (float)vtx.X;
vtxToAdd.y = (float)vtx.Z;
vtxToAdd.z = -(float)vtx.Y;
}
verticies.Add(vtxToAdd);
}
foreach (var fidx in MeshToSend.FaceIndices)
{
int vtxCt = (int)fidx.Count;
faceVtxCt.Add(vtxCt);
if (vtxCt == 3)
{
faceCnx.Add((int)fidx.A);
faceCnx.Add((int)fidx.B);
faceCnx.Add((int)fidx.C);
}
else
{
faceCnx.Add((int)fidx.A);
faceCnx.Add((int)fidx.B);
faceCnx.Add((int)fidx.C);
faceCnx.Add((int)fidx.D);
}
}
//create maya mesh
if (nodeExists)
{
mfnMesh.createInPlace(numVert, numPoly, verticies, faceVtxCt, faceCnx);
mfnMesh.Dispose();
}
else
{
using (var obj = mfnMesh.create(numVert, numPoly, verticies, faceVtxCt, faceCnx))
{
MFnDependencyNode nodeFn = new MFnDagNode(obj);
nodeFn.setName(name);
MGlobal.executeCommand("sets -e -forceElement initialShadingGroup " + nodeFn.name);
mfnMesh.Dispose();
}
}
return(true);
}
public static void ToMaya(Curve CurveToSend, string name)
{
NurbsCurve ctsAsNurb = null;
if (CurveToSend is Rectangle)
{
Rectangle rec = (Rectangle)CurveToSend;
ctsAsNurb = NurbsCurve.ByControlPoints(rec.Points, 1, true);
}
else if (CurveToSend is Polygon)
{
Polygon rec = (Polygon)CurveToSend;
ctsAsNurb = NurbsCurve.ByControlPoints(rec.Points, 1, true);
}
else
{
ctsAsNurb = CurveToSend.ToNurbsCurve();
}
var ncd = new MFnNurbsCurveData();
MFnNurbsCurveForm mfnform;
if (ctsAsNurb.IsClosed)
{
mfnform = MFnNurbsCurveForm.kClosed;
}
else
{
mfnform = MFnNurbsCurveForm.kOpen;
}
var mayaCurve = new MFnNurbsCurve();
var vtxs = new MPointArray();
var cvs = ctsAsNurb.ControlPoints();
var yUp = MGlobal.isYAxisUp;
if (yUp)
{
foreach (var cv in cvs)
{
var pt = new MPoint(cv.X, cv.Z, -cv.Y);
vtxs.Add(pt);
//pt.Dispose();
}
}
else
{
foreach (var cv in cvs)
{
var pt = new MPoint(cv.X, cv.Y, cv.Z);
vtxs.Add(pt);
//pt.Dispose();
}
}
var knots = ctsAsNurb.Knots();
var crvKnots = new MDoubleArray(knots);
crvKnots.RemoveAt(0);
crvKnots.RemoveAt(crvKnots.Count - 1);
MDagPath node = null;
var nodeExists = false;
Task checkNode = null;
Task deleteNode = null;
try
{
node = DMInterop.getDagNode(name);
nodeExists = true;
}
catch (Exception)
{
nodeExists = false;
}
MObject obj;
if (nodeExists)
{
MDagPath nodeShape = node;
nodeShape.extendToShape();
var modifyCrv = new MDGModifier();
mayaCurve = new MFnNurbsCurve(nodeShape);
try
{
MFnNurbsCurveData dataCreator = new MFnNurbsCurveData();
MObject outCurveData = dataCreator.create();
var span = (vtxs.Count - ctsAsNurb.Degree);
string rblCmd = $"rebuildCurve -rt 0 -s {span} -d {ctsAsNurb.Degree} {name}";
if (mayaCurve.numCVs != vtxs.Count || mayaCurve.degree != ctsAsNurb.Degree)
{
MGlobal.executeCommand(rblCmd);
}
mayaCurve.setCVs(vtxs);
mayaCurve.setKnots(crvKnots, 0, crvKnots.length - 1);
mayaCurve.updateCurve();
modifyCrv.doIt();
if (CurveToSend.GetType() == typeof(Circle))
{
span = 8;
rblCmd = $"rebuildCurve -rt 0 -s {span} {name}";
MGlobal.executeCommand(rblCmd);
}
}
catch (Exception e)
{
MGlobal.displayWarning(e.Message);
}
}
else
{
obj = mayaCurve.create(vtxs, crvKnots, (uint)ctsAsNurb.Degree, (MFnNurbsCurve.Form)mfnform,
false, ctsAsNurb.IsRational);
MFnDependencyNode nodeFn = new MFnDagNode(obj);
nodeFn.setName(name);
}
}
public static int[] ConnectedVtxID(this Mesh m, int vtxIndex)
{
return(DMInterop.GetConnectedPointID(m, vtxIndex));
}
public static void ToMaya(CoordinateSystem csToSend, string name)
{
double x = 0, y = 0, z = 0, rx = 0, ry = 0, rz = 0;
Vector vec = Vector.ByCoordinates(0, 0, 0);
if (MGlobal.isYAxisUp)
{
x = csToSend.Origin.X;
y = csToSend.Origin.Z;
z = -csToSend.Origin.Y;
Vector vecX = Vector.ByCoordinates(csToSend.XAxis.X, csToSend.XAxis.Z, -csToSend.XAxis.Y);
Vector vecY = Vector.ByCoordinates(csToSend.YAxis.X, csToSend.YAxis.Z, -csToSend.YAxis.Y);
Vector vecZ = Vector.ByCoordinates(csToSend.ZAxis.X, csToSend.ZAxis.Z, -csToSend.ZAxis.Y);
rx = vecX.AngleWithVector(Vector.XAxis());
ry = vecX.AngleWithVector(Vector.ZAxis());
rz = vecX.AngleWithVector(Vector.YAxis().Reverse());
}
else
{
x = csToSend.Origin.X;
y = csToSend.Origin.Y;
z = csToSend.Origin.Z;
Vector vecX = Vector.ByCoordinates(csToSend.XAxis.X, csToSend.XAxis.Y, csToSend.XAxis.Z);
Vector vecY = Vector.ByCoordinates(csToSend.YAxis.X, csToSend.YAxis.Y, csToSend.YAxis.Z);
Vector vecZ = Vector.ByCoordinates(csToSend.ZAxis.X, csToSend.ZAxis.Y, csToSend.ZAxis.Z);
rx = vecX.AngleWithVector(Vector.XAxis());
ry = vecX.AngleWithVector(Vector.YAxis());
rz = vecX.AngleWithVector(Vector.ZAxis());
}
MDagPath node = null;
bool nodeExists = false;
Task checkNode = null;
Task makeChangeTask = null;
try
{
checkNode = Task.Factory.StartNew(() => node = DMInterop.getDagNode(name));
checkNode.Wait(5000);
nodeExists = true;
}
catch (Exception)
{
nodeExists = false;
}
if (nodeExists)
{
if (checkNode.IsCompleted)
{
makeChangeTask = Task.Factory.StartNew(() => changeLocator(x, y, z, rx, ry, rz, name));
makeChangeTask.Wait(5000);
}
}
else
{
if (checkNode.IsCompleted)
{
makeChangeTask = Task.Factory.StartNew(() => createLocator(x, y, z, rx, ry, rz, name));
makeChangeTask.Wait(5000);
}
}
}
private void dynMeshToMayaMesh(string name, Mesh dynMesh = null, TSplineSurface tsMesh = null)
{
bool nodeExists = false;
MDagPath node = null;
Task unpackTask = null;
Task mobjTask = null;
try
{
node = DMInterop.getDagNode(name);
nodeExists = true;
}
catch (Exception)
{
nodeExists = false;
}
MIntArray faceCnx = new MIntArray();
MFloatPointArray verticies = new MFloatPointArray();
MIntArray faceVtxCt = new MIntArray();
int numVert = 0;
int numPoly = 0;
if (dynMesh != null)
{
numVert = dynMesh.VertexPositions.Length;
numPoly = dynMesh.FaceIndices.Length;
unpackTask = Task.Factory.StartNew(() => unpackDynMesh(dynMesh, out faceCnx, out verticies, out faceVtxCt));
unpackTask.Wait(4000);
}
if (tsMesh != null)
{
numVert = tsMesh.VerticesCount;
numPoly = tsMesh.FacesCount;
unpackTask = Task.Factory.StartNew(() => unpackTsMesh(tsMesh, out faceCnx, out verticies, out faceVtxCt));
unpackTask.Wait(4000);
}
if (nodeExists)
{
try
{
meshFn = new MFnMesh(node);
meshFn.createInPlace(numVert, numPoly, verticies, faceVtxCt, faceCnx);
}
catch (Exception e)
{
MGlobal.displayWarning(e.Message);
}
}
else
{
try
{
dagMod = new MDagModifier();
// Create a mesh data wrapper to hold the new geometry.
MFnMeshData dataFn = new MFnMeshData();
MObject dataWrapper = dataFn.create();
// Create the mesh geometry and put it into the wrapper.
meshFn = new MFnMesh();
MObject dataObj = meshFn.create(numVert, numPoly, verticies, faceVtxCt, faceCnx, dataWrapper);
MObject transform = dagMod.createNode("mesh", MObject.kNullObj);
dagMod.doIt();
renameNodes(transform, name);
dagMod.doIt();
assignShadingGroup(transform, "initialShadingGroup");
dagMod.doIt();
setMeshData(transform, dataWrapper);
}
catch (Exception e)
{
MGlobal.displayWarning(e.Message);
}
}
//GC.Collect();
//GC.WaitForPendingFinalizers();
}
