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));
}
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);
}
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);
}
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 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);
}
}
}
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 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);
}
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();
}
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);
}
}
