public override void doIt(MArgList argl)
{
SubscribeAssemblyResolvingEvent();
if (!String.IsNullOrEmpty(wpfTitle))
{
// Check the existence of the window
int wndExist = int.Parse(MGlobal.executeCommandStringResult($@"format -stringArg `control -q -ex ""{wpfTitle}""` ""^1s"""));
if (wndExist > 0)
{
MGlobal.executeCommand($@"catch (`workspaceControl -e -visible true ""{hostTitle}""`);");
return;
}
}
if (dynStartUp != null)
{
if (dynStartUp.DynView != null)
{
if (dynStartUp.DynView.IsVisible)
{
MGlobal.displayWarning("Dynamo is already open");
return;
}
else
{
dynWnd.Show();
}
}
}
else
{
newDmStartup();
dynWnd = dynStartUp.DynView;
// Create the window to dock
dynWnd.Show();
// Extract the window handle of the window we want to dock
IntPtr mWindowHandle = new System.Windows.Interop.WindowInteropHelper(dynWnd).Handle;
int width = (int)dynWnd.Width;
int height = (int)dynWnd.Height;
var title = dynWnd.Title;
wpfTitle = title + " Internal";
hostTitle = title;
dynWnd.Title = wpfTitle;
mayaWnd = new MForeignWindowWrapper(mWindowHandle, true);
uint flagIdx = argl.flagIndex(flagName);
if (flagIdx == MArgList.kInvalidArgIndex)
{
// Create a workspace-control to wrap the native window wrapper, and use it as the parent of this WPF window
CreateWorkspaceControl(wpfTitle, hostTitle, width, height, false);
}
}
}
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++;
}
}
internal void GetNewGeom()
{
// VMDataBridge.DataBridge.Instance.UnregisterCallback(GUID.ToString());
if (firstRun)
{
firstRun = false;
}
else
{
if (SelectedItems != null)
{
foreach (var itm in SelectedItems.Values)
{
itm.Dispose();
}
}
}
MSelectionList selectionList = new MSelectionList();
MGlobal.getActiveSelectionList(selectionList, true);
if (selectionList.isEmpty)
{
if (selectionList.isEmpty)
{
SelectedItems = null;
OnNodeModified(true);
return;
}
}
var TransObjectList = selectionList.DagPaths(MFn.Type.kTransform).ToList();
var DagObjectList = selectionList.DagPaths(MFn.Type.kMesh).ToList();
SelectedItems = new Dictionary <string, DMMesh>(DagObjectList.Count);
m_SelectedItemNames = new List <string>(DagObjectList.Count);
foreach (var dag in TransObjectList)
{
if (dag.hasFn(MFn.Type.kMesh))
{
var itm = new DMMesh(dag, space);
itm.Renamed += Itm_Renamed;
itm.Deleted += MObjOnDeleted;
SelectedItems.Add(itm.dagName, itm);
m_SelectedItemNames.Add(itm.dagName);
// ct++;
}
else
{
MGlobal.displayWarning($"Selected item is not a kMesh, it is a {dag.apiType}");
}
}
m_SelectedItemNamesString = ConvertStringListToString(m_SelectedItemNames);
OnNodeModified(true);
}
private void View_Closed(object sender, EventArgs e)
{
//DynamoView dv = (DynamoView)sender;
if (!dynStartUp.DynViewModel.PerformShutdownSequence(new DynamoViewModel.ShutdownParams(false, true, true)))
{
MGlobal.displayWarning("Could not shut down");
}
dynStartUp.DynView.Close();
dynStartUp = null;
}
//public void SetupDynamo(out DynamoViewModel viewModel)
public void SetupDynamo( )
{
SubscribeAssemblyResolvingEvent();
UpdateSystemPathForProcess();
PreloadDynamoCoreDlls();
var corePath = DynamoCorePath;
var dynamoMayaExeLoc = Assembly.GetExecutingAssembly().Location;
var dynamoMayaRoot = Path.GetDirectoryName(dynamoMayaExeLoc);
var userDataFolder = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"Dynamo", "Dynamo Core");
var commonDataFolder = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
"Dynamo", "Dynamo Core");
var geometryFactoryPath = string.Empty;
var preloaderLocation = string.Empty;
var loadedLibGVersion = PreloadAsmFromMayaATF();
try
{
if (isDynModelNull)
{
DynModel = DynamoModel.Start(
new DynamoModel.DefaultStartConfiguration
{
DynamoCorePath = corePath,
DynamoHostPath = corePath,
GeometryFactoryPath = GetGeometryFactoryPath(corePath, loadedLibGVersion),
PathResolver = new PathResolver(userDataFolder, commonDataFolder),
});
isDynModelNull = false;
}
if (isDynViewModelNull)
{
DynViewModel = DynamoViewModel.Start(
new DynamoViewModel.StartConfiguration
{
// CommandFilePath = commandFilePath,
DynamoModel = DynModel
});
isDynViewModelNull = false;
}
}
catch (Exception e)
{
MGlobal.displayWarning(e.Message);
}
}
public static List <object> MelCommand(string MelCommand)
{
MStringArray stringResults = new MStringArray();
MIntArray intResults = new MIntArray();
MDoubleArray doubleResults = new MDoubleArray();
MVectorArray vectorResults = new MVectorArray();
List <object> results = new List <object>();
MCommandResult mcr = new MCommandResult();
MDagPath dag = new MDagPath();
try
{
MGlobal.executeCommand(MelCommand, mcr);
// MGlobal.executeCommand(MelCommand, stringResults);
}
catch (MemberAccessException e)
{
MGlobal.displayWarning(e.Message);
}
switch (mcr.resultType)
{
case MCommandResult.Type.kStringArray:
mcr.getResult(stringResults);
results.AddRange(stringResults);
break;
case MCommandResult.Type.kIntArray:
mcr.getResult(intResults);
results.AddRange(intResults.Cast <object>());
break;
case MCommandResult.Type.kDoubleArray:
mcr.getResult(doubleResults);
results.AddRange(doubleResults.Cast <object>());
break;
case MCommandResult.Type.kVectorArray:
mcr.getResult(vectorResults);
results.AddRange(vectorResults.Cast <object>());
break;
default:
mcr.getResult(stringResults);
results.AddRange(stringResults);
break;
}
mcr.Dispose();
return(results);
}
public void eventCallback(object sender, MBasicFunctionArgs args)
{
if (data >= 0 && data < (int)eventTestCmd.eventNames.Length)
{
MGlobal.displayInfo("event " +
eventTestCmd.eventNames[data] +
" occurred\n");
}
else
{
MGlobal.displayWarning("BOGUS client data in eventCB!\n");
}
}
internal static string ConvertStringListToString(List <string> stringList)
{
if (stringList.Count > 0)
{
string listAsString = "";
for (int i = 0; i < stringList.Count - 1; i++)
{
listAsString += stringList[i] + ",";
}
listAsString += stringList[stringList.Count - 1];
return(listAsString);
}
MGlobal.displayWarning("selected items are invalid");
return("");
}
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);
}
}
public override void doPress(MEvent eventArg)
{
base.doPress(eventArg);
// If we are not in selecting mode (i.e. an object has been selected)
// then set up for the translation.
if (!_isSelecting())
{
eventArg.getPosition(ref startPos_x, ref startPos_y);
view = M3dView.active3dView;
MDagPath camera = view.Camera;
MFnCamera fnCamera = new MFnCamera(camera);
MVector upDir = fnCamera.upDirection(MSpace.Space.kWorld);
MVector rightDir = fnCamera.rightDirection(MSpace.Space.kWorld);
// Determine the camera used in the current view
if (fnCamera.isOrtho)
{
if (upDir.isEquivalent(MVector.zNegAxis, 1e-3))
{
currWin = 0; // TOP
}
else if (rightDir.isEquivalent(MVector.xAxis, 1e-3))
{
currWin = 1; // FRONT
}
else
{
currWin = 2; // SIDE
}
}
else
{
currWin = 3; // PERSP
MGlobal.displayWarning("moveTool only works in top, front and side views");
}
// Create an instance of the move tool command.
cmd = _newToolCommand() as moveCmd;
cmd.setVector(0.0, 0.0, 0.0);
}
}
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;
}
}
}
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 void updateManipulators(RotateManipContext ctx)
{
if (ctx == null)
{
return;
}
ctx.deleteManipulators();
// Add the rotate manipulator to each selected object. This produces
// behavior different from the default rotate manipulator behavior. Here,
// a distinct rotate manipulator is attached to every object.
//
try
{
MSelectionList list = MGlobal.activeSelectionList;
MItSelectionList iter = new MItSelectionList(list, MFn.Type.kInvalid);
for (; !iter.isDone; iter.next())
{
// Make sure the selection list item is a depend node and has the
// required plugs before manipulating it.
//
MObject dependNode = new MObject();
iter.getDependNode(dependNode);
if (dependNode.isNull || !dependNode.hasFn(MFn.Type.kDependencyNode))
{
MGlobal.displayWarning("Object in selection list is not a depend node.");
continue;
}
MFnDependencyNode dependNodeFn = new MFnDependencyNode(dependNode);
try
{
/* MPlug rPlug = */
dependNodeFn.findPlug("rotate");
}
catch (System.Exception)
{
MGlobal.displayWarning("Object cannot be manipulated: " + dependNodeFn.name);
continue;
}
// Add manipulator to the selected object
//
MObject manipObject = new MObject();
exampleRotateManip manipulator;
try
{
manipulator = exampleRotateManip.newManipulator("exampleRotateManipCSharp", manipObject) as exampleRotateManip;
// Add the manipulator
//
ctx.addManipulator(manipObject);
// Connect the manipulator to the object in the selection list.
//
try
{
manipulator.connectToDependNode(dependNode);
}
catch (System.Exception)
{
MGlobal.displayWarning("Error connecting manipulator to object: " + dependNodeFn.name);
}
}
catch (System.Exception)
{
}
}
}
catch (System.Exception)
{
}
}
void AddOneCommand(CommandData cd)
{
//Debug.Log("try add:" + cd.DebugMessage());
string realSubMenuName = "";
if (cd.subMenuName == null)
{
realSubMenuName = totalMenuName;
}
else
{
string[] labelLayers = cd.subMenuName.Split('/');
string[] menuLayers = new string[labelLayers.Length];
menuLayers[0] = labelLayers[0];
for (int i = 1; i < menuLayers.Length; i++)
{
menuLayers[i] = labelLayers[i] + menuLayers[i - 1];
}
string lastRealName = totalMenuName;
for (int i = 0; i < menuLayers.Length; i++)
{
if (subMenuDic.ContainsKey(menuLayers[i]))
{
lastRealName = subMenuDic[menuLayers[i]];
continue;
}
else
{
lastRealName = AddSubMenu(lastRealName, labelLayers[i], true);
subMenuDic.Add(menuLayers[i], lastRealName);
}
}
realSubMenuName = lastRealName;
//if (subMenuDic.ContainsKey(cd.subMenuName))
//{
// realSubMenuName = subMenuDic[cd.subMenuName];
//}
//else
//{
// realSubMenuName = AddSubMenu(totalMenuName, cd.subMenuName, true);
// subMenuDic.Add(cd.subMenuName, realSubMenuName);
//}
}
if (cd.isDivider)
{
AddMenuItemDivider(cd.labelStr, realSubMenuName);
return;
}
Dictionary <string, Action> paramActionDic;
if (commandDic.ContainsKey(cd.cmdTypeStr))
{
paramActionDic = commandDic[cd.cmdTypeStr];
}
else
{
paramActionDic = new Dictionary <string, Action>();
commandDic.Add(cd.cmdTypeStr, paramActionDic);
}
if (paramActionDic.ContainsKey(cd.paramStr))
{
MGlobal.displayWarning("Repeated Command Param:" + cd.paramStr);
while (paramActionDic.ContainsKey(cd.paramStr))
{
cd.paramStr += "_r";
}
MGlobal.displayWarning("Rename to:" + cd.paramStr);
}
paramActionDic.Add(cd.paramStr, cd.action);
AddMenuItem(cd.labelStr, realSubMenuName, "InazumaCommand", cd.cmdTypeStr + " " + cd.paramStr);
}
