public override void connectToDependNode(MObject node) { // Find the rotate and rotatePivot plugs on the node. These plugs will // be attached either directly or indirectly to the manip values on the // rotate manip. // MFnDependencyNode nodeFn = new MFnDependencyNode(node); MPlug rPlug = nodeFn.findPlug("rotate"); MPlug rcPlug = nodeFn.findPlug("rotatePivot"); // If the translate pivot exists, it will be used to move the state manip // to a convenient location. // MPlug tPlug = nodeFn.findPlug("translate"); // To avoid having the object jump back to the default rotation when the // manipulator is first used, extract the existing rotation from the node // and set it as the initial rotation on the manipulator. // MEulerRotation existingRotation = new MEulerRotation(vectorPlugValue(rPlug)); MVector existingTranslation = new MVector(vectorPlugValue(tPlug)); // // The following code configures default settings for the rotate // manipulator. // MFnRotateManip rotateManip = new MFnRotateManip(fRotateManip); rotateManip.setInitialRotation(existingRotation); rotateManip.setRotateMode(MFnRotateManip.RotateMode.kObjectSpace); rotateManip.displayWithNode(node); // Add a callback function to be called when the rotation value changes // //rotatePlugIndex = addManipToPlugConversionCallback( rPlug, (manipToPlugConversionCallback)&exampleRotateManip::rotationChangedCallback ); ManipToPlugConverion[rPlug] = rotationChangedCallback; // get the index of plug rotatePlugIndex = this[rPlug]; // Create a direct (1-1) connection to the rotation center plug // rotateManip.connectToRotationCenterPlug(rcPlug); // Place the state manip at a distance of 2.0 units away from the object // along the X-axis. // MFnStateManip stateManip = new MFnStateManip(fStateManip); MVector delta = new MVector(2, 0, 0); stateManip.setTranslation(existingTranslation + delta, MSpace.Space.kTransform); finishAddingManips(); base.connectToDependNode(node); }
public static bool ProjectPlug(MPlug from, MPlug to, float fromMin, float fromMax, float toMin, float toMax) { MFnDependencyNode remapValueNode = BasicFunc.CreateRemapValueNode(fromMin, fromMax, toMin, toMax); MDGModifier dGModifier = new MDGModifier(); dGModifier.connect(from, remapValueNode.findPlug(ConstantValue.plugName_remapValueInput)); dGModifier.connect(remapValueNode.findPlug(ConstantValue.plugName_remapValueOutput), to); dGModifier.doIt(); return(true); }
public override void connectToDependNode(MObject node) { // Find the rotate and rotatePivot plugs on the node. These plugs will // be attached either directly or indirectly to the manip values on the // rotate manip. // MFnDependencyNode nodeFn = new MFnDependencyNode(node); MPlug rPlug = nodeFn.findPlug("rotate"); MPlug rcPlug = nodeFn.findPlug("rotatePivot"); // If the translate pivot exists, it will be used to move the state manip // to a convenient location. // MPlug tPlug = nodeFn.findPlug("translate"); // To avoid having the object jump back to the default rotation when the // manipulator is first used, extract the existing rotation from the node // and set it as the initial rotation on the manipulator. // MEulerRotation existingRotation = new MEulerRotation(vectorPlugValue(rPlug)); MVector existingTranslation = new MVector(vectorPlugValue(tPlug)); // // The following code configures default settings for the rotate // manipulator. // MFnRotateManip rotateManip = new MFnRotateManip(fRotateManip); rotateManip.setInitialRotation(existingRotation); rotateManip.setRotateMode(MFnRotateManip.RotateMode.kObjectSpace); rotateManip.displayWithNode(node); // Add a callback function to be called when the rotation value changes // //rotatePlugIndex = addManipToPlugConversionCallback( rPlug, (manipToPlugConversionCallback)&exampleRotateManip::rotationChangedCallback ); ManipToPlugConverion[rPlug] = rotationChangedCallback; // get the index of plug rotatePlugIndex = this[rPlug]; // Create a direct (1-1) connection to the rotation center plug // rotateManip.connectToRotationCenterPlug(rcPlug); // Place the state manip at a distance of 2.0 units away from the object // along the X-axis. // MFnStateManip stateManip = new MFnStateManip(fStateManip); MVector delta = new MVector(2, 0, 0); stateManip.setTranslation(existingTranslation + delta, MSpace.Space.kTransform); finishAddingManips(); base.connectToDependNode(node); }
public static MFnDependencyNode CreateRemapValueNode(float inputMin, float inputMax, float outputMin, float outputMax) { MFnDependencyNode dependencyNode = new MFnDependencyNode(); dependencyNode.create("remapValue"); //Debug.Log("created node:" + (*dependencyNode).absoluteName()); dependencyNode.findPlug("inputMin").setFloat(inputMin); dependencyNode.findPlug("inputMax").setFloat(inputMax); dependencyNode.findPlug("outputMin").setFloat(outputMin); dependencyNode.findPlug("outputMax").setFloat(outputMax); return(dependencyNode); }
/// <summary> /// Extract a material and its linked texture, if any. /// </summary> private static void ExtractMaterial(MayaM2Mesh mesh, MObject material) { var fnShader = new MFnLambertShader(material); // Get lambert out of the shader var strName = fnShader.name; MGlobal.displayInfo("Detected material : " + strName + " of type " + material.apiTypeStr); //TODO use this type // ReSharper disable once UnusedVariable var clrDiffuse = fnShader.color; // ReSharper disable once UnusedVariable var clrAmbient = fnShader.ambientColor; if (material.hasFn(MFn.Type.kReflect)) { var fnReflectShader = new MFnReflectShader(material); // ReSharper disable once UnusedVariable var clrSpec = fnReflectShader.specularColor; } // Look for textures at the color plug var colorPlug = fnShader.findPlug("color"); var fileTextureIter = new MItDependencyGraph(colorPlug.node, MFn.Type.kFileTexture, MItDependencyGraph.Direction.kUpstream, MItDependencyGraph.Traversal.kDepthFirst, MItDependencyGraph.Level.kNodeLevel); while (!fileTextureIter.isDone) { //TODO hardcoded textures var nodeFn = new MFnDependencyNode(fileTextureIter.thisNode()); var fileNamePlug = nodeFn.findPlug("fileTextureName"); string textureFileName; fileNamePlug.getValue(out textureFileName); MGlobal.displayInfo("\t Texture found : " + textureFileName); var wrapUPlug = nodeFn.findPlug("wrapU"); var wrapU = false; wrapUPlug.getValue(ref wrapU); var wrapVPlug = nodeFn.findPlug("wrapV"); var wrapV = false; wrapVPlug.getValue(ref wrapV); var tex = new MayaM2Texture { WrapU = wrapU, WrapV = wrapV }; mesh.Textures.Add(tex); fileTextureIter.next();//maybe now the loop is fixed } }
public static void StuckNClothTimeWhenNotDynamic(MFnDependencyNode dn) { MPlug plug_isDynamic = dn.findPlug(ConstantValue.plugName_nCloth_isDynamic); MPlug plug_currentTime = dn.findPlug(ConstantValue.plugName_nCloth_currentTime); if (plug_isDynamic != null && plug_currentTime != null) { MPlugArray inputArr_currentTime = new MPlugArray(); plug_currentTime.connectedTo(inputArr_currentTime, true, false); MFnDependencyNode dn_time = new MFnDependencyNode(inputArr_currentTime[0].node); BindAttr.ProjectPlug(plug_isDynamic, dn_time.findPlug(ConstantValue.plugName_nClothTime_nodeState), 0, 1, (int)ConstantValue.TimeNodeState.Stuck, (int)ConstantValue.TimeNodeState.Normal); } }
public static MFnDependencyNode CreateLayeredTextureNode(List <MFnDependencyNode> imageNodes) { //MFnDependencyNode layeredTextureNode = new MFnDependencyNode(); //layeredTextureNode.create("layeredTexture"); MFnDependencyNode layeredTextureNode = CreateShadingNode(ShadingNodeType.Utility, "layeredTexture"); MPlug layeredTexInputsPlug = layeredTextureNode.findPlug(ConstantValue.plugName_layeredTextureInputs); //check place2DTextures MDGModifier dGModifier = new MDGModifier(); for (int i = 0; i < imageNodes.Count; i++) { //place2dTexture setting MFnDependencyNode p2dNode = GetPlace2dTextureForTex(imageNodes[i]); p2dNode.findPlug("wrapU").setBool(false); p2dNode.findPlug("translateFrameU").setFloat(i); //set tex default color to 0 imageNodes[i].findPlug(ConstantValue.plugName_fileTexDefaultColorR).setFloat(0); imageNodes[i].findPlug(ConstantValue.plugName_fileTexDefaultColorG).setFloat(0); imageNodes[i].findPlug(ConstantValue.plugName_fileTexDefaultColorB).setFloat(0); //move uv MSelectionList matList = GetMaterialsWithTex(imageNodes[i]); for (int j = 0; j < matList.length; j++) { MObject matObj = new MObject(); matList.getDependNode((uint)j, matObj); string matName = new MFnDependencyNode(matObj).absoluteName; Debug.Log("move uv for mat:" + matName); MoveUV(i, 0, matName); } MPlug layeredTexInputPlug = layeredTexInputsPlug.elementByLogicalIndex((uint)i); MPlug texOutColorPlug = imageNodes[i].findPlug(ConstantValue.plugName_fileTexOutputColor); MPlug layeredTexInputColor = layeredTexInputPlug.child((int)ConstantValue.LayeredTextureInputDataIndex.Color); dGModifier.connect(texOutColorPlug, layeredTexInputColor); //set blendMode to add MPlug blendMode = layeredTexInputPlug.child((int)ConstantValue.LayeredTextureInputDataIndex.BlendMode); if (i < imageNodes.Count - 1) { blendMode.setInt((int)ConstantValue.LayeredTextureBlendMode.Add); } else { blendMode.setInt((int)ConstantValue.LayeredTextureBlendMode.None); } } dGModifier.doIt(); return(layeredTextureNode); }
public static void BindNCloth(MSelectionList selecteList = null) { if (selecteList == null) { selecteList = BasicFunc.GetSelectedList(); } int count = (int)selecteList.length; if (count <= 1) { //Debug.Log("ncloth control switch target: select [ctl,ncloth0,ncloth1...]"); return; } else { //Debug.Log("ncloth control switch target count:" + count); } MDagPath ctlDag = new MDagPath(); selecteList.getDagPath(0, ctlDag); selecteList.remove(0); MFnDependencyNode dn_ctl = new MFnDependencyNode(ctlDag.node); BasicFunc.IterateSelectedDags((dag) => { //Debug.Log("ncloth control set for:"+dag.fullPathName); MPlug ctlNewAttrPlug = BindAttr.AddBoolAttr(dn_ctl, "Dynamic_" + dag.partialPathName, true, "", false); dag.extendToShape(); MFnDependencyNode dn_nCloth = new MFnDependencyNode(dag.node); MPlug plug_isDynamic = dn_nCloth.findPlug(ConstantValue.plugName_nCloth_isDynamic); MPlug plug_currentTime = dn_nCloth.findPlug(ConstantValue.plugName_nCloth_currentTime); if (plug_isDynamic != null && plug_currentTime != null) { MPlugArray inputArr_currentTime = new MPlugArray(); plug_currentTime.connectedTo(inputArr_currentTime, true, false); MFnDependencyNode dn_time = new MFnDependencyNode(inputArr_currentTime[0].node); BindAttr.ProjectPlug(plug_isDynamic, dn_time.findPlug(ConstantValue.plugName_nClothTime_nodeState), 0, 1, (int)ConstantValue.TimeNodeState.Stuck, (int)ConstantValue.TimeNodeState.Normal); } BasicFunc.ConnectPlug(ctlNewAttrPlug, plug_isDynamic); }, MFn.Type.kNCloth, selecteList); //List<string> nclothNameList = new List<string>(); //foreach (MDagPath dag in nclothList.DagPaths()) //{ // nclothNameList.Add() //} }
// get the plug at the node public MPlug getPlug(string node_name, string attribute_name) { var dn = new MFnDependencyNode(getDependNode(node_name)); var pl = dn.findPlug(attribute_name); return(pl); }
// The compute() method does the actual work of the node using the inputs // of the node to generate its output. // // Compute takes two parameters: plug and data. // - Plug is the the data value that needs to be recomputed // - Data provides handles to all of the nodes attributes, only these // handles should be used when performing computations. // public override bool compute(MPlug plug, MDataBlock dataBlock) { MObject thisNode = thisMObject(); MFnDependencyNode fnThisNode = new MFnDependencyNode(thisNode); MGlobal.displayInfo("affects::compute(), plug being computed is \"" + plug.name + "\""); if (plug.partialName() == "B") { // Plug "B" is being computed. Assign it the value on plug "A" // if "A" exists. // MPlug pA = fnThisNode.findPlug("A"); MGlobal.displayInfo("\t\t... found dynamic attribute \"A\", copying its value to \"B\""); MDataHandle inputData = dataBlock.inputValue(pA); int value = inputData.asInt; MDataHandle outputHandle = dataBlock.outputValue(plug); outputHandle.set(value); dataBlock.setClean(plug); } else { return(false); } return(true); }
public static void DeleteUnusedShadingNode(MSelectionList list) { if (list == null) { Debug.Log("list null"); return; } List <MFnDependencyNode> deleteList = new List <MFnDependencyNode>(); for (int i = 0; i < list.length; i++) { MObject mo = new MObject(); list.getDependNode((uint)i, mo); if (mo.hasFn(MFn.Type.kShadingEngine)) { MFnDependencyNode sgNode = new MFnDependencyNode(mo); MPlug plug_dagSetMemebers = sgNode.findPlug(ConstantValue.plugName_dagSetMembers); Debug.Log("numelements:" + plug_dagSetMemebers.numElements); if (plug_dagSetMemebers.numElements == 0) { deleteList.Add(sgNode); } } //Debug.Log(sgNode.name); } BasicFunc.DeleteObjects(deleteList); }
private MFnDependencyNode getTextureDependencyNode(MFnDependencyNode materialDependencyNode, string plugName) { MPlug mPlug = materialDependencyNode.findPlug(plugName); if (mPlug == null || mPlug.isNull || !mPlug.isConnected) { return(null); } MObject sourceObject = mPlug.source.node; MFnDependencyNode textureDependencyNode = new MFnDependencyNode(sourceObject); RaiseMessage(materialDependencyNode.name + "." + plugName, logRankTexture); // Bump texture uses an intermediate node if (sourceObject.hasFn(MFn.Type.kBump)) { Print(textureDependencyNode, logRankTexture, "Print bump node"); logRankTexture++; return(getTextureDependencyNode(textureDependencyNode, "bumpValue")); } // If a reverse node is used as an intermediate node if (sourceObject.hasFn(MFn.Type.kReverse)) { // TODO - reverse? logRankTexture++; return(getTextureDependencyNode(textureDependencyNode, "input")); } return(textureDependencyNode); }
public MObject findShadingEngine(MObject node) // // Description: // Given the material MObject this method will // return the shading group that it is assigned to. // if there is no shading group associated with // the material than a null MObject is apssed back. // { MFnDependencyNode nodeFn = new MFnDependencyNode(node); MPlug srcPlug = nodeFn.findPlug("outColor"); MPlugArray nodeConnections = new MPlugArray(); srcPlug.connectedTo(nodeConnections, false, true); //loop through the connections //and find the shading engine node that //it is connected to // for (int i = 0; i < nodeConnections.length; i++) { if (nodeConnections[i].node.hasFn(MFn.Type.kShadingEngine)) { return(nodeConnections[i].node); } } //no shading engine associated so return a //null MObject // return(new MObject()); }
// // Description: // Overloaded function from MPxDragAndDropBehavior // this method will assign the correct output from the slope shader // onto the given attribute. // public override void connectNodeToAttr(MObject sourceNode, MPlug destinationPlug, bool force) { MFnDependencyNode src = new MFnDependencyNode(sourceNode); //if we are dragging from a slopeShaderNodeCSharp //to a shader than connect the outColor //plug to the plug being passed in // if(destinationPlug.node.hasFn(MFn.Type.kLambert)) { if (src.typeName == "slopeShaderNodeCSharp") { MPlug srcPlug = src.findPlug("outColor"); if(!srcPlug.isNull && !destinationPlug.isNull) { string cmd = "connectAttr "; cmd += srcPlug.name + " "; cmd += destinationPlug.name; MGlobal.executeCommand(cmd); } } } else { //in all of the other cases we do not need the plug just the node //that it is on // MObject destinationNode = destinationPlug.node; connectNodeToNode(sourceNode, destinationNode, force); } }
// The compute() method does the actual work of the node using the inputs // of the node to generate its output. // // Compute takes two parameters: plug and data. // - Plug is the the data value that needs to be recomputed // - Data provides handles to all of the nodes attributes, only these // handles should be used when performing computations. // public override bool compute(MPlug plug, MDataBlock dataBlock) { MObject thisNode = thisMObject(); MFnDependencyNode fnThisNode = new MFnDependencyNode(thisNode); MGlobal.displayInfo("affects::compute(), plug being computed is \"" + plug.name + "\""); if (plug.partialName() == "B") { // Plug "B" is being computed. Assign it the value on plug "A" // if "A" exists. // MPlug pA = fnThisNode.findPlug("A"); MGlobal.displayInfo("\t\t... found dynamic attribute \"A\", copying its value to \"B\""); MDataHandle inputData = dataBlock.inputValue(pA); int value = inputData.asInt; MDataHandle outputHandle = dataBlock.outputValue( plug ); outputHandle.set(value); dataBlock.setClean(plug); } else { return false; } return true; }
public static MFnDependencyNode GetPlace2dTextureForTex(MFnDependencyNode imageNode, bool createIfNotExist = true) { if (imageNode == null) { Debug.Log("image Node null"); return(null); } MPlug uvPlug = imageNode.findPlug(ConstantValue.plugName_texFileUVCoord); MPlugArray sourcePlugs = new MPlugArray(); uvPlug.connectedTo(sourcePlugs, true, false); if (sourcePlugs.length == 0) { //no input if (createIfNotExist) { MFnDependencyNode place2dTexNode = CreateShadingNode(ShadingNodeType.Utility, "place2dTexture"); MPlug p2tUVOut = place2dTexNode.findPlug(ConstantValue.plugName_place2dOutUV); string nodeName = place2dTexNode.absoluteName; MDGModifier dgModifier = new MDGModifier(); dgModifier.connect(p2tUVOut, uvPlug); dgModifier.doIt(); return(place2dTexNode); } else { return(null); } } else { return(new MFnDependencyNode(sourcePlugs[0].node)); } }
private static List <Material> GetMaterialsMesh(ref MFnMesh Mesh, ref MDagPath Path) { // Get materials for this mesh var Result = new List <Material>(); // Fetch data var Shaders = new MObjectArray(); var ShaderIndices = new MIntArray(); Mesh.getConnectedShaders(Path.instanceNumber, Shaders, ShaderIndices); // Iterate and add for (int i = 0; i < (int)Shaders.length; i++) { // Find plug var ShaderNode = new MFnDependencyNode(Shaders[i]); var ShaderPlug = ShaderNode.findPlug("surfaceShader"); var MatPlug = new MPlugArray(); ShaderPlug.connectedTo(MatPlug, true, false); if (MatPlug.length > 0) { Result.Add(new Material(CleanNodeName(new MFnDependencyNode(MatPlug[0].node).name))); } } return(Result); }
/// <summary> /// Originally written in C++ by RobTheBloke. /// See https://nccastaff.bournemouth.ac.uk/jmacey/RobTheBloke/www/research/maya/mfnmesh.htm /// </summary> /// <param name="shadingEngine"></param> /// <returns>The shader name.</returns> private static MObjectArray GetMaterials(MObject shadingEngine) { // attach a function set to the shading engine var fn = new MFnDependencyNode(shadingEngine); // get access to the surfaceShader attribute. This will be connected to // lambert , phong nodes etc. var sShader = fn.findPlug("surfaceShader"); // will hold the connections to the surfaceShader attribute var materials = new MPlugArray(); // get the material connected to the surface shader sShader.connectedTo(materials, true, false); var materialsObjects = new MObjectArray(); if (materials.Count <= 0) { return(materialsObjects); } // if we found a material foreach (var plug in materials) { materialsObjects.Add(plug.node); } return(materialsObjects); }
public static void RemoveUnusedTextures(MSelectionList list) { if (list == null) { Debug.Log("list null"); return; } List <MObject> deleteList = new List <MObject>(); for (int i = 0; i < list.length; i++) { MObject mo = new MObject(); list.getDependNode((uint)i, mo); MFnDependencyNode imageNode = new MFnDependencyNode(mo); MPlug texOutputPlug = imageNode.findPlug(ConstantValue.plugName_fileTexOutputColor); MPlugArray destPlugs = new MPlugArray(); texOutputPlug.destinations(destPlugs); if (destPlugs.Count == 0) { deleteList.Add(mo); Debug.Log("remove no use:" + imageNode.absoluteName); } else { Debug.Log("still used:" + imageNode.absoluteName); for (int j = 0; j < destPlugs.length; j++) { Debug.Log(" by:" + destPlugs[0].partialName(true)); } } } BasicFunc.DeleteObjects(deleteList); }
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); }
private void ExportCommonBabylonAttributes(MFnDependencyNode babylonAttributesDependencyNode, BabylonMaterial babylonMaterial) { bool backfaceCulling = babylonAttributesDependencyNode.findPlug("babylonBackfaceCulling").asBool(); RaiseVerbose("backfaceCulling=" + backfaceCulling, 3); babylonMaterial.backFaceCulling = backfaceCulling; int maxSimultaneousLights = babylonAttributesDependencyNode.findPlug("babylonMaxSimultaneousLights").asInt(); RaiseVerbose("maxSimultaneousLights=" + maxSimultaneousLights, 3); babylonMaterial.maxSimultaneousLights = maxSimultaneousLights; bool unlit = babylonAttributesDependencyNode.findPlug("babylonUnlit").asBool(); RaiseVerbose("unlit=" + unlit, 3); babylonMaterial.isUnlit = unlit; }
private void ExportCommonBabylonAttributes(MFnDependencyNode babylonAttributesDependencyNode, BabylonPBRMetallicRoughnessMaterial babylonMaterial) { ExportCommonBabylonAttributes0(babylonAttributesDependencyNode, babylonMaterial); if (babylonAttributesDependencyNode.hasAttribute("babylonTransparencyMode")) { int v = babylonAttributesDependencyNode.findPlug("babylonTransparencyMode").asInt(); RaiseVerbose($"babylonTransparencyMode={v}", 3); babylonMaterial.transparencyMode = v; } }
public static MSelectionList GetMaterialsWithTex(MFnDependencyNode imageNode, out MPlugArray texColorDestPlugs, out MPlugArray texTransparencyDestPlugs) { MPlug plug = imageNode.findPlug(ConstantValue.plugName_fileTexOutputColor); texColorDestPlugs = new MPlugArray(); plug.destinations(texColorDestPlugs); MPlug plug_outTransparency = imageNode.findPlug(ConstantValue.plugName_fileTexOutputTransparency); texTransparencyDestPlugs = new MPlugArray(); plug_outTransparency.destinations(texTransparencyDestPlugs); //BasicFunc.PrintPlugs(destPlugs); MSelectionList newSelection = new MSelectionList(); for (int i = 0; i < texColorDestPlugs.length; i++) { newSelection.add(texColorDestPlugs[i].node); } //BasicFunc.Select(newSelection); return(newSelection); }
public static string RenameTexFile(MFnDependencyNode imageNode, string newPartialName, string newFolder = null, bool relinkImgNode = false, bool deleteOrigin = false, bool overwrite = false) { MPlug plug_fileTexPath = imageNode.findPlug(ConstantValue.plugName_fileTexPath); string originFullPath = plug_fileTexPath.asString(); string newFullPath = BasicFunc.RenameFile(originFullPath, newPartialName, newFolder, deleteOrigin, overwrite); if (relinkImgNode) { plug_fileTexPath.setString(newFullPath); } return(newFullPath); }
private bool isPBRMaterial(MFnDependencyNode materialDependencyNode) { string graphAttribute = "graph"; if (materialDependencyNode.hasAttribute(graphAttribute)) { string graphValue = materialDependencyNode.findPlug(graphAttribute).asStringProperty; return(graphValue.Contains("stingray")); } else { return(false); } }
private void ExportCommonBabylonAttributes0(MFnDependencyNode babylonAttributesDependencyNode, BabylonMaterial babylonMaterial) { // Backface Culling if (babylonAttributesDependencyNode.hasAttribute("babylonBackfaceCulling")) { bool v = babylonAttributesDependencyNode.findPlug("babylonBackfaceCulling").asBool(); RaiseVerbose($"backfaceCulling={v}", 3); babylonMaterial.backFaceCulling = v; } // unlit if (babylonAttributesDependencyNode.hasAttribute("babylonUnlit")) { bool v = babylonAttributesDependencyNode.findPlug("babylonUnlit").asBool(); RaiseVerbose($"isUnlit={v}", 3); babylonMaterial.isUnlit = v; } // max light if (babylonAttributesDependencyNode.hasAttribute("babylonMaxSimultaneousLights")) { int v = babylonAttributesDependencyNode.findPlug("babylonMaxSimultaneousLights").asInt(); RaiseVerbose($"maxSimultaneousLights={v}", 3); babylonMaterial.maxSimultaneousLights = v; } }
private bool isStingrayPBSMaterial(MFnDependencyNode materialDependencyNode) { // TODO - Find a better way to identify material type string graphAttribute = "graph"; if (materialDependencyNode.hasAttribute(graphAttribute)) { string graphValue = materialDependencyNode.findPlug(graphAttribute).asString(); return(graphValue.Contains("stingray")); } else { return(false); } }
public static bool ConnectPlug(MFnDependencyNode dn_from, string plugName_from, MFnDependencyNode dn_to, string plugName_to, MDGModifier dGModifier = null, bool doit = true) { if (dn_from != null && dn_to != null) { MPlug from = dn_from.findPlug(plugName_from); if (from != null) { MPlug to = dn_to.findPlug(plugName_to); if (to != null) { return(ConnectPlug(from, to, dGModifier, doit)); } } } return(false); }
// The setDependentsDirty() method allows attributeAffects relationships // in a much more general way than via MPxNode::attributeAffects // which is limited to static attributes only. // The setDependentsDirty() method allows relationships to be established // between any combination of dynamic and static attributes. // // Within a setDependentsDirty() implementation you get passed in the // plug which is being set dirty, and then, based upon which plug it is, // you may choose to dirty any other plugs by adding them to the // affectedPlugs list. // // In almost all cases, the relationships you set up will be fixed for // the duration of Maya, such as "A affects B". However, you can also // set up relationships which depend upon some external factor, such // as the current frame number, the time of day, if maya was invoked in // batch mode, etc. These sorts of relationships are straightforward to // implement in your setDependentsDirty() method. // // There may also be situations where you need to look at values in the // dependency graph. It is VERY IMPORTANT that when accessing DG values // you do not cause a DG evaluation. This is because your setDependentsDirty() // method is called during dirty processing and causing an evalutaion could // put Maya into an infinite loop. The only safe way to look at values // on plugs is via the MDataBlock::outputValue() which does not trigger // an evaluation. It is recommeneded that you only look at plugs whose // values are constant or you know have already been computed. // // For this example routine, we will only implement the simplest case // of a relationship. // public override void setDependentsDirty(MPlug plugBeingDirtied, MPlugArray affectedPlugs) { MObject thisNode = thisMObject(); MFnDependencyNode fnThisNode = new MFnDependencyNode(thisNode); if (plugBeingDirtied.partialName() == "A") { // "A" is dirty, so mark "B" dirty if "B" exists. // This implements the relationship "A affects B". // MGlobal.displayInfo("affects::setDependentsDirty, \"A\" being dirtied"); MPlug pB = fnThisNode.findPlug("B"); MGlobal.displayInfo("\t\t... dirtying \"B\"\n"); affectedPlugs.append(pB); } return; }
public static void ChangeTexturesPrefix(MSelectionList list, string newFolderPath) { if (list == null) { Debug.Log("list null"); return; } for (int i = 0; i < list.length; i++) { MObject mo = new MObject(); list.getDependNode((uint)i, mo); MFnDependencyNode imageNode = new MFnDependencyNode(mo); MPlug plug = imageNode.findPlug(ConstantValue.plugName_fileTexPath); string filePath = plug.asString(); Debug.Log("filePath:" + filePath); string fileName = Path.GetFileName(filePath); plug.setString(Path.Combine(newFolderPath, fileName)); } }
public static void RenameTextures(MSelectionList list) { if (list == null) { Debug.Log("list null"); return; } for (int i = 0; i < list.length; i++) { MObject mo = new MObject(); list.getDependNode((uint)i, mo); MFnDependencyNode imageNode = new MFnDependencyNode(mo); MPlug plug = imageNode.findPlug(ConstantValue.plugName_fileTexPath); string filePath = plug.asString(); Debug.Log("filePath:" + filePath); string fileName = BasicFunc.GetFileName(filePath); Debug.Log("fileName:" + fileName); imageNode.setName(fileName); } }
public static void RenameMaterials(MSelectionList list) { if (list == null) { Debug.Log("list null"); return; } for (int i = 0; i < list.length; i++) { MObject mo = new MObject(); list.getDependNode((uint)i, mo); MFnDependencyNode matNode = new MFnDependencyNode(mo); MPlug plug = matNode.findPlug(ConstantValue.plugName_matColorInput); MPlug sourcePlug = plug.source; if (sourcePlug != null) { MFnDependencyNode sourceNode = new MFnDependencyNode(sourcePlug.node); matNode.setName("mat_" + sourceNode.name); } } }
// ------------------------- // --------- Utils --------- // ------------------------- private string getSourcePathFromFileTexture(MFnDependencyNode textureDependencyNode) { MObject sourceObject = textureDependencyNode.objectProperty; // Retreive texture file path if (!sourceObject.hasFn(MFn.Type.kFileTexture)) { RaiseError("Only file texture is supported.", logRankTexture + 1); return(null); } MPlug fileTextureNamePlug = textureDependencyNode.findPlug("fileTextureName"); if (fileTextureNamePlug == null || fileTextureNamePlug.isNull) { RaiseError("Texture path is missing.", logRankTexture + 1); return(null); } string sourcePath = fileTextureNamePlug.asString(); return(sourcePath); }
public override void connectNodeToAttr(MObject sourceNode, MPlug destinationPlug, bool force) // // Description: // Overloaded function from MPxDragAndDropBehavior // this method will assign the correct output from the slope shader // onto the given attribute. // { MFnDependencyNode src = new MFnDependencyNode(sourceNode); //if we are dragging from a slopeShaderNodeCSharp //to a shader than connect the outColor //plug to the plug being passed in // if(destinationPlug.node.hasFn(MFn.Type.kLambert)) { if (src.typeName == "slopeShaderNodeCSharp") { MPlug srcPlug = src.findPlug("outColor"); if(!srcPlug.isNull && !destinationPlug.isNull) { string cmd = "connectAttr "; cmd += srcPlug.name + " "; cmd += destinationPlug.name; MGlobal.executeCommand(cmd); } } } else { //in all of the other cases we do not need the plug just the node //that it is on // MObject destinationNode = destinationPlug.node; connectNodeToNode(sourceNode, destinationNode, force); } }
// The setDependentsDirty() method allows attributeAffects relationships // in a much more general way than via MPxNode::attributeAffects // which is limited to static attributes only. // The setDependentsDirty() method allows relationships to be established // between any combination of dynamic and static attributes. // // Within a setDependentsDirty() implementation you get passed in the // plug which is being set dirty, and then, based upon which plug it is, // you may choose to dirty any other plugs by adding them to the // affectedPlugs list. // // In almost all cases, the relationships you set up will be fixed for // the duration of Maya, such as "A affects B". However, you can also // set up relationships which depend upon some external factor, such // as the current frame number, the time of day, if maya was invoked in // batch mode, etc. These sorts of relationships are straightforward to // implement in your setDependentsDirty() method. // // There may also be situations where you need to look at values in the // dependency graph. It is VERY IMPORTANT that when accessing DG values // you do not cause a DG evaluation. This is because your setDependentsDirty() // method is called during dirty processing and causing an evalutaion could // put Maya into an infinite loop. The only safe way to look at values // on plugs is via the MDataBlock::outputValue() which does not trigger // an evaluation. It is recommeneded that you only look at plugs whose // values are constant or you know have already been computed. // // For this example routine, we will only implement the simplest case // of a relationship. // public override void setDependentsDirty(MPlug plugBeingDirtied, MPlugArray affectedPlugs) { MObject thisNode = thisMObject(); MFnDependencyNode fnThisNode = new MFnDependencyNode(thisNode); if (plugBeingDirtied.partialName() == "A") { // "A" is dirty, so mark "B" dirty if "B" exists. // This implements the relationship "A affects B". // MGlobal.displayInfo("affects::setDependentsDirty, \"A\" being dirtied"); MPlug pB = fnThisNode.findPlug("B"); MGlobal.displayInfo("\t\t... dirtying \"B\"\n"); affectedPlugs.append(pB); } return; }
public Material MakeMaterial(MFnMesh fnMesh) { MaterialGroup matGroup =new MaterialGroup () ; MObjectArray shaders =new MObjectArray() ; MIntArray indices =new MIntArray () ; fnMesh.getConnectedShaders (0, shaders, indices) ; for ( int i =0 ; i < shaders.length ; i++ ) { MFnDependencyNode shaderGroup =new MFnDependencyNode (shaders [i]) ; MPlug shaderPlug =shaderGroup.findPlug ("surfaceShader") ; MPlugArray connections =new MPlugArray () ; shaderPlug.connectedTo (connections, true, false) ; for ( int u =0 ; u < connections.length ; u++ ) { MFnDependencyNode depNode =new MFnDependencyNode (connections [u].node) ; //MPlug colorPlug =depNode.findPlug ("color") ; //MColor mcolor =new MColor () ; ///*MPlugArray cc =new MPlugArray () ; //colorPlug.connectedTo (cc, true , false) ; //if ( cc.length > 0 ) { // // Plug is driven by an input connection. // for ( int v =0 ; v < cc.length ; v++ ) { // MPlug color2Plug =cc [v] ; // Console.WriteLine (color2Plug.numChildren) ; // color2Plug.child (0).getValue (mcolor.r) ; // color2Plug.child (1).getValue (mcolor.g) ; // color2Plug.child (2).getValue (mcolor.b) ; // //color2Plug.child (3).getValue (mcolor.a) ; // } //} else {*/ // mcolor.r =colorPlug.child (0).asFloat () ; // mcolor.g =colorPlug.child (1).asFloat () ; // mcolor.b =colorPlug.child (2).asFloat () ; // //colorPlug.child (3).getValue (mcolor.a) ; ////} //MPlug trPlug =depNode.findPlug ("transparency") ; //float transparency =1.0f - trPlug.child (0).asFloat () ; ////return new DiffuseMaterial (new SolidColorBrush (Color.FromScRgb (transparency, mcolor.r, mcolor.g, mcolor.b))) ; //DiffuseMaterial diffuse =new DiffuseMaterial (new SolidColorBrush (Color.FromScRgb (transparency, mcolor.r, mcolor.g, mcolor.b))) ; //colorPlug =depNode.findPlug ("ambientColor") ; //mcolor.r =colorPlug.child (0).asFloat () ; //mcolor.g =colorPlug.child (1).asFloat () ; //mcolor.b =colorPlug.child (2).asFloat () ; //diffuse.AmbientColor =Color.FromScRgb (transparency, mcolor.r, mcolor.g, mcolor.b) ; //matGroup.Children.Add (diffuse) ; //colorPlug =depNode.findPlug ("specularColor") ; //mcolor.r =colorPlug.child (0).asFloat () ; //mcolor.g =colorPlug.child (1).asFloat () ; //mcolor.b =colorPlug.child (2).asFloat () ; //MPlug powerPlug =depNode.findPlug ("cosinePower") ; //SpecularMaterial specular =new SpecularMaterial (new SolidColorBrush (Color.FromScRgb (1.0f, mcolor.r, mcolor.g, mcolor.b)), powerPlug.asDouble ()) ; //matGroup.Children.Add (specular) ; //EmissiveMaterial emissive =new EmissiveMaterial () ; //matGroup.Children.Add (emissive) ; try { MFnLambertShader lambert =new MFnLambertShader (connections [u].node) ; SolidColorBrush brush =new SolidColorBrush (Color.FromScRgb (1.0f - lambert.transparency.r, lambert.color.r, lambert.color.g, lambert.color.b)) ; brush.Opacity =1.0f - lambert.transparency.r ; DiffuseMaterial diffuse =new DiffuseMaterial (brush) ; diffuse.AmbientColor =Color.FromScRgb (1.0f - lambert.ambientColor.a, lambert.ambientColor.r, lambert.ambientColor.g, lambert.ambientColor.b) ; // no more attributes matGroup.Children.Add (diffuse) ; // No specular color EmissiveMaterial emissive =new EmissiveMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - lambert.incandescence.a, lambert.incandescence.r, lambert.incandescence.g, lambert.incandescence.b))) ; // no more attributes matGroup.Children.Add (emissive) ; } catch { } //try { // MFnReflectShader reflect =new MFnReflectShader (connections [u].node) ; // SpecularMaterial specular =new SpecularMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - reflect.specularColor.a, reflect.specularColor.r, reflect.specularColor.g, reflect.specularColor.b)), reflect.cosPower) ; // // no more attributes // matGroup.Children.Add (specular) ; //} catch { //} try { MFnPhongShader phong =new MFnPhongShader (connections [u].node) ; //See Lambert //SolidColorBrush brush =new SolidColorBrush (Color.FromScRgb (1.0f - phong.transparency.r, phong.color.r, phong.color.g, phong.color.b)) ; //brush.Opacity =1.0f - phong.transparency.r ; //DiffuseMaterial diffuse =new DiffuseMaterial (brush) ; //diffuse.AmbientColor =Color.FromScRgb (1.0f - phong.ambientColor.a, phong.ambientColor.r, phong.ambientColor.g, phong.ambientColor.b) ; //// no more attributes //matGroup.Children.Add (diffuse) ; SpecularMaterial specular =new SpecularMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - phong.specularColor.a, phong.specularColor.r, phong.specularColor.g, phong.specularColor.b)), phong.cosPower) ; // no more attributes matGroup.Children.Add (specular) ; //See Lambert //EmissiveMaterial emissive =new EmissiveMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - phong.incandescence.a, phong.incandescence.r, phong.incandescence.g, phong.incandescence.b))) ; //// no more attributes //matGroup.Children.Add (emissive) ; } catch { } // todo //try { // MFnBlinnShader phong =new MFnBlinnShader (connections [u].node) ; // //See Lambert // //SolidColorBrush brush =new SolidColorBrush (Color.FromScRgb (1.0f - phong.transparency.r, phong.color.r, phong.color.g, phong.color.b)) ; // //brush.Opacity =1.0f - phong.transparency.r ; // //DiffuseMaterial diffuse =new DiffuseMaterial (brush) ; // //diffuse.AmbientColor = Color.FromScRgb (1.0f - phong.ambientColor.a, phong.ambientColor.r, phong.ambientColor.g, phong.ambientColor.b) ; // //// no more attributes // //matGroup.Children.Add (diffuse) ; // //See Lambert // //EmissiveMaterial emissive =new EmissiveMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - phong.incandescence.a, phong.incandescence.r, phong.incandescence.g, phong.incandescence.b))) ; // //// no more attributes // //matGroup.Children.Add (emissive) ; //} catch { //} } } // Default to Blue if ( matGroup.Children.Count == 0 ) matGroup.Children.Add (new DiffuseMaterial (new SolidColorBrush (Color.FromRgb (0, 0, 255)))) ; return (matGroup) ; }
// // Description: // Given the material MObject this method will // return the shading group that it is assigned to. // if there is no shading group associated with // the material than a null MObject is apssed back. // public MObject findShadingEngine(MObject node) { MFnDependencyNode nodeFn = new MFnDependencyNode(node); MPlug srcPlug = nodeFn.findPlug("outColor"); MPlugArray nodeConnections = new MPlugArray(); srcPlug.connectedTo(nodeConnections, false, true); //loop through the connections //and find the shading engine node that //it is connected to // for(int i = 0; i < nodeConnections.length; i++) { if(nodeConnections[i].node.hasFn(MFn.Type.kShadingEngine)) return nodeConnections[i].node; } //no shading engine associated so return a //null MObject // return new MObject(); }
// // Description: // Overloaded function from MPxDragAndDropBehavior // this method will handle the connection between the slopeShaderNodeCSharp and the shader it is // assigned to as well as any meshes that it is assigned to. // public override void connectNodeToNode(MObject sourceNode, MObject destinationNode, bool force) { MFnDependencyNode src = new MFnDependencyNode(sourceNode); //if we are dragging from a lambert //we want to check what we are dragging //onto. if(sourceNode.hasFn(MFn.Type.kLambert)) { //MObject shaderNode; MPlugArray connections = new MPlugArray(); MObjectArray shaderNodes = new MObjectArray(); shaderNodes.clear(); //if the source node was a lambert //than we will check the downstream connections to see //if a slope shader is assigned to it. // src.getConnections(connections); int i; for(i = 0; i < connections.length; i++) { //check the incoming connections to this plug // MPlugArray connectedPlugs = new MPlugArray(); connections[i].connectedTo(connectedPlugs, true, false); for(uint j = 0; j < connectedPlugs.length; j++) { //if the incoming node is a slope shader than //append the node to the shaderNodes array // MObject currentnode = connectedPlugs[i].node; if (new MFnDependencyNode(currentnode).typeName == "slopeShaderNodeCSharp") { shaderNodes.append(currentnode); } } } //if we found a shading node //than check the destination node //type to see if it is a mesh // if(shaderNodes.length > 0) { MFnDependencyNode dest = new MFnDependencyNode(destinationNode); if(destinationNode.hasFn(MFn.Type.kMesh)) { //if the node is a mesh than for each slopeShaderNodeCSharp //connect the worldMesh attribute to the dirtyShaderPlug //attribute to force an evaluation of the node when the mesh //changes // for(i = 0; i < shaderNodes.length; i++) { MPlug srcPlug = dest.findPlug("worldMesh"); MPlug destPlug = new MFnDependencyNode(shaderNodes[i]).findPlug("dirtyShaderPlug"); if(!srcPlug.isNull && !destPlug.isNull) { string cmd = "connectAttr -na "; cmd += srcPlug.name + " "; cmd += destPlug.name; try { // in slopeShaderBehavior.cpp, this may excute failed but continue on the following code, so we catch it. MGlobal.executeCommand(cmd); } catch (System.Exception) { MGlobal.displayError("ExcuteCommand (" + cmd + ") failed."); } } } //get the shading engine so we can assign the shader //to the mesh after doing the connection // MObject shadingEngine = findShadingEngine(sourceNode); //if there is a valid shading engine than make //the connection // if(!shadingEngine.isNull) { string cmd = "sets -edit -forceElement "; cmd += new MFnDependencyNode(shadingEngine).name + " "; cmd += new MFnDagNode(destinationNode).partialPathName; MGlobal.executeCommand(cmd); } } } } else if (src.typeName == "slopeShaderNodeCSharp") //if we are dragging from a slope shader //than we want to see what we are dragging onto // { if(destinationNode.hasFn(MFn.Type.kMesh)) { //if the user is dragging onto a mesh //than make the connection from the worldMesh //to the dirtyShader plug on the slopeShaderNodeCSharp // MFnDependencyNode dest = new MFnDependencyNode(destinationNode); MPlug srcPlug = dest.findPlug("worldMesh"); MPlug destPlug = src.findPlug("dirtyShaderPlug"); if(!srcPlug.isNull && !destPlug.isNull) { string cmd = "connectAttr -na "; cmd += srcPlug.name + " "; cmd += destPlug.name; MGlobal.executeCommand(cmd); } } } return; }
public MObject findShadingEngine(MObject node) // // Description: // Given the material MObject this method will // return the shading group that it is assigned to. // if there is no shading group associated with // the material than a null MObject is apssed back. // { MFnDependencyNode nodeFn = new MFnDependencyNode(node); MPlug srcPlug = nodeFn.findPlug("outColor"); MPlugArray nodeConnections = new MPlugArray(); srcPlug.connectedTo(nodeConnections, false, true); //loop through the connections //and find the shading engine node that //it is connected to // for(int i = 0; i < nodeConnections.length; i++) { if(nodeConnections[i].node.hasFn(MFn.Type.kShadingEngine)) return nodeConnections[i].node; } //no shading engine associated so return a //null MObject // return new MObject(); }
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) { } }
//! Ensure that valid geometry is selected bool validGeometrySelected() { MSelectionList list = new MSelectionList(); MGlobal.getActiveSelectionList(list); MItSelectionList iter = new MItSelectionList(list, MFn.Type.kInvalid); for (; !iter.isDone; iter.next()) { MObject dependNode = new MObject(); iter.getDependNode(dependNode); if (dependNode.isNull || !dependNode.hasFn(MFn.Type.kTransform)) { MGlobal.displayWarning("Object in selection list is not right type of node"); return false; } MFnDependencyNode dependNodeFn = new MFnDependencyNode(dependNode); MStringArray attributeNames = new MStringArray(); attributeNames.append("scaleX"); attributeNames.append("translateX"); int i; for ( i = 0; i < attributeNames.length; i++ ) { MPlug plug = dependNodeFn.findPlug(attributeNames[i]); if ( plug.isNull ) { MGlobal.displayWarning("Object cannot be manipulated: " + dependNodeFn.name); return false; } } } return true; }
// get the plug at the node MPlug getPlug(string node_name, string attribute_name) { MFnDependencyNode dn = new MFnDependencyNode(getDependNode(node_name)); MPlug pl = dn.findPlug(attribute_name); return pl; }