/* static */ bool PxrUsdMayaTranslatorUtil::CreateNode( const MString& nodeName, const MString& nodeTypeName, MObject& parentNode, MStatus* status, MObject* mayaNodeObj) { // XXX: // Using MFnDagNode::create() results in nodes that are not properly // registered with parent scene assemblies. For now, just massaging the // transform code accordingly so that child scene assemblies properly post // their edits to their parents-- if this is indeed the best pattern for // this, all Maya*Reader node creation needs to be adjusted accordingly (for // much less trivial cases like MFnMesh). MDagModifier dagMod; *mayaNodeObj = dagMod.createNode(nodeTypeName, parentNode, status); CHECK_MSTATUS_AND_RETURN(*status, false); *status = dagMod.renameNode(*mayaNodeObj, nodeName); CHECK_MSTATUS_AND_RETURN(*status, false); *status = dagMod.doIt(); CHECK_MSTATUS_AND_RETURN(*status, false); return TF_VERIFY(not mayaNodeObj->isNull()); }
/* override */ MStatus offset::accessoryNodeSetup(MDagModifier& cmd) // // Description: // This method is called when the deformer is created by the // "deformer" command. You can add to the cmds in the MDagModifier // cmd in order to hook up any additional nodes that your node needs // to operate. // // In this example, we create a locator and attach its matrix attribute // to the matrix input on the offset node. The locator is used to // set the direction and scale of the random field. // // Description: // This method is optional. // { MStatus result; // hook up the accessory node // MObject objLoc = cmd.createNode(MString("locator"), MObject::kNullObj, &result); if (MS::kSuccess == result) { MFnDependencyNode fnLoc(objLoc); MString attrName; attrName.set("matrix"); MObject attrMat = fnLoc.attribute(attrName); result = cmd.connect(objLoc,attrMat,this->thisMObject(),offset::offsetMatrix); } return result; }
MStatus lrutils::makeHomeNull(MObject obj, MFnTransform& transformFn, MObject& groupObj) { MStatus status = MS::kFailure; status = transformFn.setObject(obj); MyCheckStatusReturn(status, "invalid MObject provided for MFnTransform.setObject()"); if( status == MS::kSuccess ) { MDagModifier dagMod; groupObj = dagMod.createNode( "transform", MObject::kNullObj, &status ); MyCheckStatusReturn(status, "MDagModifier.createNode() failed"); dagMod.doIt(); MFnTransform groupFn; groupFn.setObject(groupObj); groupFn.set(transformFn.transformation()); groupFn.addChild(obj); MString groupName = transformFn.name(); groupName = groupName.substring(0, groupName.numChars() - 4); groupName += "GRP"; groupFn.setName(groupName); } return status; }
MObject lrutils::createJointFromLocation(MVectorArray location, MString prefix, unsigned int num, MObject parent) { MStatus status = MS::kFailure; MObject jointObj; //make joint object MDagModifier dagMod; jointObj = dagMod.createNode( "joint", MObject::kNullObj, &status ); MyCheckStatus(status, "MDagModifier.createNode() failed"); dagMod.doIt(); //set position lrutils::setLocation(jointObj, location, MFnTransform::MFnTransform(), true, false, false); //set name MString jointName = prefix + "_Skel" + boost::lexical_cast<string>(num).c_str() + "_JNT"; dagMod.renameNode(jointObj, jointName); dagMod.doIt(); MFnTransform jointFn(jointObj); //parent the joint to its parent, if not null if(parent != MObject::kNullObj) { MFnTransform parentFn(parent); MGlobal::executeCommand("parent " + jointFn.fullPathName() + " " + parentFn.fullPathName() + ";"); } return jointObj; }
MStatus DDConvexHullCmd::doIt(const MArgList& args) { if (args.length() != 1) { MGlobal::displayError("Needs at least 2 args"); return MS::kFailure; } MString input = args.asString(0); MString output = args.asString(1); // Get the mObject for the input MSelectionList selList; selList.add(input); MDagPath inputMesh; selList.getDagPath(0, inputMesh); // Ensure we're looking at the shape inputMesh.extendToShape(); // Create output object MDagModifier dm; MObject outMeshNode = dm.createNode(MFn::kMesh); MFnDependencyNode outMeshDag(outMeshNode); outMeshDag.setName("poopShape#"); DDConvexHullUtils::hullOpts hullOptions; return DDConvexHullUtils::generateMayaHull(outMeshNode, inputMesh.node(), hullOptions); }
//----------------------------------------------------------------------------- // Adds a color set to the input history of the passed mesh //----------------------------------------------------------------------------- MObject ValveMaya::AddColorSetToMesh( const MString &colorSetName, const MDagPath &mDagPath, MDagModifier &mDagModifier ) { if ( !mDagPath.hasFn( MFn::kMesh ) ) return MObject::kNullObj; MFnMesh meshFn( mDagPath ); MString uniqueColorSetName; { MStringArray colorSetNames; meshFn.getColorSetNames( colorSetNames ); const uint nColorSets( colorSetNames.length() ); for ( int i( 0 ); uniqueColorSetName.length() == 0; ++i ) { uniqueColorSetName = colorSetName; if ( i > 0 ) { uniqueColorSetName += i; } for ( uint j( 0U ); j != nColorSets; ++j ) { if ( uniqueColorSetName == colorSetNames[ j ] ) { uniqueColorSetName.clear(); break; } } } } // Create a 'createColorSet' node MObject ccsObj( mDagModifier.MDGModifier::createNode( "createColorSet" ) ); mDagModifier.doIt(); const MFnDependencyNode ccsFn( ccsObj ); MPlug csnP( ccsFn.findPlug( "colorSetName" ) ); csnP.setValue( uniqueColorSetName ); // Insert it in the history of the mesh MPlug inMeshP( meshFn.findPlug( "inMesh" ) ); MPlugArray mPlugArray; if ( inMeshP.connectedTo( mPlugArray, true, false ) && mPlugArray.length() ) { mDagModifier.disconnect( mPlugArray[ 0 ], inMeshP ); mDagModifier.connect( mPlugArray[ 0 ], ccsFn.findPlug( "inputGeometry" ) ); } mDagModifier.connect( ccsFn.findPlug( "outputGeometry" ), inMeshP ); mDagModifier.doIt(); return ccsObj; }
/* static */ bool UsdMayaTranslatorCamera::Read( const UsdGeomCamera& usdCamera, MObject parentNode, const UsdMayaPrimReaderArgs& args, UsdMayaPrimReaderContext* context) { if (!usdCamera) { return false; } const UsdPrim& prim = usdCamera.GetPrim(); const SdfPath primPath = prim.GetPath(); MStatus status; // Create the transform node for the camera. MObject transformObj; if (!UsdMayaTranslatorUtil::CreateTransformNode(prim, parentNode, args, context, &status, &transformObj)) { return false; } // Create the camera shape node. MDagModifier dagMod; MObject cameraObj = dagMod.createNode(_tokens->MayaCameraTypeName.GetText(), transformObj, &status); CHECK_MSTATUS_AND_RETURN(status, false); status = dagMod.doIt(); CHECK_MSTATUS_AND_RETURN(status, false); TF_VERIFY(!cameraObj.isNull()); MFnCamera cameraFn(cameraObj, &status); CHECK_MSTATUS_AND_RETURN(status, false); const std::string cameraShapeName = prim.GetName().GetString() + _tokens->MayaCameraShapeNameSuffix.GetString(); cameraFn.setName(cameraShapeName.c_str(), &status); CHECK_MSTATUS_AND_RETURN(status, false); if (context) { const SdfPath shapePrimPath = primPath.AppendChild(TfToken(cameraShapeName)); context->RegisterNewMayaNode(shapePrimPath.GetString(), cameraObj); } return _ReadToCamera(usdCamera, cameraFn, args, context); }
MStatus SwirlDeformer::accessoryNodeSetup( MDagModifier &dagMod ) { MStatus stat; MObject locObj = dagMod.createNode( "locator", MObject::kNullObj, &stat ); if( !stat ) return stat; dagMod.renameNode( locObj, "swirlHandle" ); MFnDependencyNode locFn( locObj ); MObject attrMat = locFn.attribute( "matrix" ); stat = dagMod.connect( locObj, attrMat, thisMObject(), deformSpace ); return stat; }
MStatus lrutils::makeGroup(MObject & obj, MString name) { MStatus status = MS::kFailure; MDagModifier dagMod; MObject groupObj = dagMod.createNode( "transform", MObject::kNullObj, &status ); MyCheckStatusReturn(status, "MDagModifier.createNode() failed"); dagMod.doIt(); MFnTransform groupFn; groupFn.setObject(groupObj); MString groupName = name; groupName += "_GRP"; groupFn.setName(groupName); obj = groupObj; return status; }
// Break connections to this blendshape void BlendShape::breakConnections() { MStatus stat; MDagModifier dagModifier; // Clear the stored connections m_weightConnections.clear(); // Save node connections and break them MPlug weightsPlug = m_pBlendShapeFn->findPlug("weight",true); for (int i=0; i<weightsPlug.evaluateNumElements(); i++) { MPlug wPlug = weightsPlug.elementByPhysicalIndex(i); MPlugArray srcConnections; MPlugArray dstConnections; wPlug.connectedTo(srcConnections,false,true); wPlug.connectedTo(dstConnections,true,false); weightConnections wcon; for (int j=0; j<srcConnections.length(); j++) { wcon.srcConnections.append(srcConnections[j]); dagModifier.disconnect(wPlug,srcConnections[j]); dagModifier.doIt(); } for (int j=0; j<dstConnections.length(); j++) { wcon.dstConnections.append(dstConnections[j]); stat = dagModifier.disconnect(dstConnections[j],wPlug); if (MS::kSuccess != stat) { std::cout << "Error trying to disconnect plug " << wPlug.name().asChar() << " and plug " << dstConnections[j].name().asChar() << "\n"; std::cout << stat.errorString().asChar() << "\n"; std::cout.flush(); } stat = dagModifier.doIt(); if (MS::kSuccess != stat) { std::cout << "Error trying to disconnect plug " << wPlug.name().asChar() << " and plug " << dstConnections[j].name().asChar() << "\n"; std::cout << stat.errorString().asChar() << "\n"; std::cout.flush(); } } m_weightConnections.push_back(wcon); } }
void MVGMesh::setIsActive(const bool isActive) const { MStatus status; // Check is flag exists MFnMesh fn(_dagpath); MPlug mvgPlug = fn.findPlug(_MVG, false, &status); if(!status && !isActive) return; if(!status && isActive) { // Create MayaMVG attribute MDagModifier dagModifier; MFnNumericAttribute nAttr; MObject mvgAttr = nAttr.create(_MVG, "mvg", MFnNumericData::kBoolean); status = dagModifier.addAttribute(_object, mvgAttr); CHECK(status) dagModifier.doIt(); mvgPlug = fn.findPlug(_MVG, false, &status); } status = mvgPlug.setValue(isActive); CHECK(status) if(isActive) { status = MGlobal::executePythonCommand("from mayaMVG import scale"); CHECK(status) MString cmd; // Retrieve transform node cmd.format("scale.getParent(\"^1s\")", _dagpath.fullPathName()); MString transform; status = MGlobal::executePythonCommand(cmd, transform); // Freeze transform mesh cmd.format("makeIdentity -apply true \"^1s\"", transform); status = MGlobal::executeCommand(cmd); CHECK(status) // Lock node cmd.format("scale.lockNode(\"^1s\", True)", transform); status = MGlobal::executePythonCommand(cmd); CHECK(status) } else {
void MeshGitCmd::connectNodes(MString nodeName, MString locatorName){ MGlobal::displayInfo("Connecting " + nodeName + " and " + locatorName); MStatus status; //Get Node Object MSelectionList nodeList; status = nodeList.add(nodeName); MObject nodeObject; status = nodeList.getDependNode(0, nodeObject); reportError(status); //Get Viz Object MSelectionList vizList; status = vizList.add(locatorName); MObject vizObject; status = vizList.getDependNode(0, vizObject); reportError(status); //Create Node Fn MeshGitFn mgFn; status = mgFn.setObject(nodeObject); reportError(status); //Create viz fn MFnDependencyNode vizFn(vizObject, &status); //Get the node plug MPlug nodePlug = mgFn.findPlug("message", true, &status); reportError(status); //Get the viz plug MPlug vizPlug = vizFn.findPlug(MeshGitLocatorNode::meshGitNodeConnection, true, &status); //Connect the plugs MDagModifier modifier; status = modifier.connect(nodePlug,vizPlug); reportError(status); status = modifier.doIt(); }
// Restore connections on this blendshape void BlendShape::restoreConnections() { MDagModifier dagModifier; // Recreate stored connections on the weight attributes MPlug weightsPlug = m_pBlendShapeFn->findPlug("weight",true); for (int i=0; i<weightsPlug.evaluateNumElements(); i++) { MPlug wPlug = weightsPlug.elementByPhysicalIndex(i); weightConnections& wcon = m_weightConnections[i]; for (int j=0; j<wcon.srcConnections.length(); j++) { dagModifier.connect(wPlug,wcon.srcConnections[j]); dagModifier.doIt(); } for (int j=0; j<wcon.dstConnections.length(); j++) { dagModifier.connect(wcon.dstConnections[j],wPlug); dagModifier.doIt(); } } }
//------------------------------------------------------------------------------ // bool CacheRepresentation::activate() { AssemblyDefinition* const assembly = dynamic_cast< AssemblyDefinition* >( getAssembly() ); if ( assembly == 0 ) { return false; } // Create a gpuCache node, and parent it to our container. MDagModifier dagMod; MStatus status; MObject cacheObj = dagMod.createNode( MString("gpuCache"), assembly->thisMObject(), &status); if (status != MStatus::kSuccess) { int isLoaded = false; // Validate that the gpuCache plugin is loaded. MGlobal::executeCommand( "pluginInfo -query -loaded gpuCache", isLoaded ); if(!isLoaded){ MString errorString = MStringResource::getString(rCreateGPUCacheNodeError, status); MGlobal::displayError(errorString); } return false; } status = dagMod.doIt(); if (status != MStatus::kSuccess) { return false; } // Set the cache attribute to point to our Alembic file. MFnDependencyNode cache(cacheObj); MPlug fileName = cache.findPlug(MString("cacheFileName"), true, &status); if (status != MStatus::kSuccess) { return false; } fileName.setValue(assembly->getRepData(getName())); return status == MStatus::kSuccess; }
//----------------------------------------------------------------------------- // Called when the user undoes the command //----------------------------------------------------------------------------- MStatus CVstAttachmentCmd::undoIt() { if ( m_undoable ) { MGlobal::setActiveSelectionList( m_mSelectionList ); m_mSelectionList.clear(); if ( m_mDagModifier ) { m_mDagModifier->undoIt(); delete m_mDagModifier; m_mDagModifier = NULL; } } return MS::kSuccess; }
MStatus CVstAimCmd::undoIt() { if ( m_undoable ) { // Undo it... whatever that takes but the scene should be restored // to the exact same state as it was just before doIt() // was called (this includes active selection, etc...) MGlobal::setActiveSelectionList( m_mSelectionList ); m_mSelectionList.clear(); if ( m_mDagModifier ) { m_mDagModifier->undoIt(); delete m_mDagModifier; m_mDagModifier = NULL; } } return MS::kSuccess; }
//----------------------------------------------------------------------------- // Creates a vstAttachment Locator //----------------------------------------------------------------------------- MStatus CVstAttachmentCmd::DoCreate() { MDagModifier *mDagModifier( new MDagModifier ); if ( !mDagModifier ) { merr << "Can't create new MDagModifier" << std::endl; return MS::kFailure; } MString optName( "vstAttachment" ); if ( m_mArgDatabase->isFlagSet( kOptName ) ) { m_mArgDatabase->getFlagArgument( kOptName, 0, optName ); } // Create the helper bone locator's transform MObject xObj = mDagModifier->createNode( "transform" ); mDagModifier->doIt(); if ( xObj.isNull() ) { merr << "Can't create new transform node" << std::endl; return MS::kFailure; } // name the shape & the transform the same thing mDagModifier->renameNode( xObj, optName ); mDagModifier->doIt(); MObject vstAttachmentObj = mDagModifier->createNode( "vstAttachment", xObj ); if ( vstAttachmentObj.isNull() ) { merr << "Can't create new vstAttachment node" << std::endl; mDagModifier->undoIt(); return MS::kFailure; } // name the shape & the transform the same thing mDagModifier->renameNode( vstAttachmentObj, MFnDependencyNode( xObj ).name() ); mDagModifier->doIt(); m_undoable = true; m_mDagModifier = mDagModifier; if ( m_mArgDatabase->isFlagSet( kOptParent ) ) { MSelectionList mSelectionList; m_mArgDatabase->getObjects( mSelectionList ); for ( MItSelectionList sIt( mSelectionList, MFn::kDagNode ); !sIt.isDone(); sIt.next() ) { MDagPath mDagPath; if ( sIt.getDagPath( mDagPath ) ) { m_mDagModifier->reparentNode( xObj, mDagPath.node() ); m_mDagModifier->doIt(); break; } } } // Save the current selection just in case we want to undo stuff MGlobal::getActiveSelectionList( m_mSelectionList ); MDagPath xDagPath; MDagPath::getAPathTo( xObj, xDagPath ); MGlobal::select( xDagPath, MObject::kNullObj, MGlobal::kReplaceList ); setResult( xDagPath.partialPathName() ); return MS::kSuccess; }
//------------------------------------------------------------------------------ // bool LocatorRepresentation::activate() { MPxAssembly* const assembly = getAssembly(); // Create a locator node, and parent it to our container. MDagModifier dagMod; MStatus status; dagMod.createNode(MString("locator"), assembly->thisMObject(), &status); if (status != MStatus::kSuccess) { return false; } status = dagMod.doIt(); if (status != MStatus::kSuccess) { return false; } // If we have annotation text, create an annotation shape, and a // transform for it. Parent the annotation transform to the assembly. if (fAnnotation.numChars() > 0) { MObject transformObj = dagMod.createNode( MString("transform"), assembly->thisMObject(), &status); if (status != MStatus::kSuccess) { return false; } MString annotationName = "annotation"; // the + "#" forces Maya to rename using integers for unique names MString transformName = annotationName + "#"; dagMod.renameNode(transformObj, transformName); status = dagMod.doIt(); if (status != MStatus::kSuccess) { return false; } MObject annotationObj = dagMod.createNode( MString("annotationShape"), transformObj, &status); if (status != MStatus::kSuccess) { return false; } status = dagMod.doIt(); if (status != MStatus::kSuccess) { return false; } // Set the annotation text. MFnDependencyNode annotation(annotationObj); MPlug text = annotation.findPlug(MString("text"), true, &status); if (status != MStatus::kSuccess) { return false; } text.setValue(fAnnotation); // Get rid of the arrow: our annotation doesn't need to be // offset from the locator for readability, since the locator // has no volume. Therefore, we don't need an arrow to point // from the annotation back to the object. MPlug displayArrow = annotation.findPlug(MString("displayArrow"), true, &status); if (status != MStatus::kSuccess) { return false; } displayArrow.setValue(false); } return status == MStatus::kSuccess; }
MStatus CmpMeshModifierCmd::transferTweaks( const MDagPath &shapePath, MObject &tweakNode, MDagModifier &dagMod ) { // Get the tweaks from the mesh shape and apply them to the // to the tweak node MFnDagNode shapeNodeFn( shapePath ); MPlug srcTweaksPlug = shapeNodeFn.findPlug( "pnts" ); MFnDependencyNode tweakNodeFn( tweakNode ); MPlug dstTweaksPlug = tweakNodeFn.findPlug( "tweak" ); //MGlobal::displayInfo( MString( "storing tweaks from " ) + shapePath.fullPathName() + "\n" ); MPlugArray plugs; MPlug srcTweakPlug; MPlug dstTweakPlug; MObject dataObj; MFloatVector tweak; unsigned int nTweaks = srcTweaksPlug.numElements(); unsigned int i, j, ci, logicalIndex; for( i=0; i < nTweaks; i++ ) { srcTweakPlug = srcTweaksPlug.elementByPhysicalIndex( i ); if( !srcTweakPlug.isNull() ) { logicalIndex = srcTweakPlug.logicalIndex(); // Set tweak node tweak element srcTweakPlug.getValue( dataObj ); MFnNumericData numDataFn( dataObj ); numDataFn.getData( tweak[0], tweak[1], tweak[2] ); dagMod.commandToExecute( MString( "setAttr " ) + tweakNodeFn.name() + ".tweak[" + logicalIndex + "] " + tweak[0] + " " + tweak[1] + " " + tweak[2] ); // Handle transfer of incoming and outgoing connections to "pnts" elements dstTweakPlug = dstTweaksPlug.elementByLogicalIndex(logicalIndex); if( srcTweakPlug.isConnected() ) { // As source, transfer source to tweak node tweak srcTweakPlug.connectedTo( plugs, false, true ); for( j=0; j < plugs.length(); j++ ) { dagMod.disconnect( srcTweakPlug, plugs[j] ); dagMod.connect( dstTweakPlug, plugs[j] ); } // As destination, transfer destination to tweak node tweak srcTweakPlug.connectedTo( plugs, true, false ); if( plugs.length() == 1 ) // There can only be one input connection { dagMod.disconnect( plugs[0], srcTweakPlug ); dagMod.connect( plugs[0], dstTweakPlug ); } } else // Check children { MPlug srcTweakChildPlug; MPlug dstTweakChildPlug; for( ci=0; ci < srcTweakPlug.numChildren(); ci++ ) { srcTweakChildPlug = srcTweakPlug.child(ci); dstTweakChildPlug = dstTweakPlug.child(ci); if( srcTweakChildPlug.isConnected() ) { // As souce, transfer source to tweak node tweak srcTweakChildPlug.connectedTo( plugs, false, true ); for( j=0; j < plugs.length(); j++ ) { dagMod.disconnect( srcTweakChildPlug, plugs[j] ); dagMod.connect( dstTweakChildPlug, plugs[j] ); } // As destination, transfer destination to tweak node tweak srcTweakChildPlug.connectedTo( plugs, true, false ); if( plugs.length() == 1 ) // There can only be one input connection { dagMod.disconnect( plugs[0], srcTweakChildPlug ); dagMod.connect( plugs[0], dstTweakChildPlug ); } } } } // With the tweak values and any connections now transferred to // the tweak node's tweak element, this source element can be reset dagMod.commandToExecute( MString( "setAttr " ) + shapePath.fullPathName() + ".pnts[" + logicalIndex + "] 0 0 0" ); //MGlobal::displayInfo( MString(" tweak: ") + tweakIndices[i] + ": " + tweaks[i].x + ", " + tweaks[i].y + ", " + tweaks[i].z + "\n" ); } } return MS::kSuccess; }
MStatus Molecule3Cmd::redoIt() { MStatus stat; MDagPath dagPath; MFnMesh meshFn; // Create a ball int nBallPolys; MPointArray ballVerts; MIntArray ballPolyCounts; MIntArray ballPolyConnects; MFloatArray ballUCoords; MFloatArray ballVCoords; MIntArray ballFvUVIDs; genBall( MPoint::origin, ballRodRatio * radius.value(), segs, nBallPolys, ballVerts, ballPolyCounts, ballPolyConnects, true, ballUCoords, ballVCoords, ballFvUVIDs ); unsigned int i, j, vertOffset; MPointArray meshVerts; MPoint p0, p1; MObject objTransform; // Setup for rods int nRodPolys; MPointArray rodVerts; MIntArray rodPolyCounts; MIntArray rodPolyConnects; MFloatArray rodUCoords; MFloatArray rodVCoords; MIntArray rodFvUVIDs; // Setup for newMesh int nNewPolys; MPointArray newVerts; MIntArray newPolyCounts; MIntArray newPolyConnects; MFloatArray newUCoords; MFloatArray newVCoords; MIntArray newFvUVIDs; int uvOffset; MDagModifier dagMod; MFnDagNode dagFn; objTransforms.clear(); // Iterate over the meshes unsigned int mi; for( mi=0; mi < selMeshes.length(); mi++ ) { dagPath = selMeshes[mi]; meshFn.setObject( dagPath ); uvOffset = 0; nNewPolys = 0; newVerts.clear(); newPolyCounts.clear(); newPolyConnects.clear(); newUCoords.clear(); newVCoords.clear(); newFvUVIDs.clear(); // Generate balls meshFn.getPoints( meshVerts, MSpace::kWorld ); for( i=0; i < meshVerts.length(); i++ ) { vertOffset = newVerts.length(); // Add the ball to the new mesh nNewPolys += nBallPolys; // Move the ball vertices to the mesh vertex. Add it to the newMesh for( j=0; j < ballVerts.length(); j++ ) newVerts.append( meshVerts[i] + ballVerts[j] ); for( j=0; j < ballPolyCounts.length(); j++ ) newPolyCounts.append( ballPolyCounts[j] ); for( j=0; j < ballPolyConnects.length(); j++ ) newPolyConnects.append( vertOffset + ballPolyConnects[j] ); // Only add the uv coordinates once, since they are shared // by all balls if( i == 0 ) { for( j=0; j < ballUCoords.length(); j++ ) { newUCoords.append( ballUCoords[j] ); newVCoords.append( ballVCoords[j] ); } } for( j=0; j < ballFvUVIDs.length(); j++ ) { newFvUVIDs.append( uvOffset + ballFvUVIDs[j] ); } } uvOffset = newUCoords.length(); // Generate rods int nRods = 0; MItMeshEdge edgeIter( dagPath ); for( ; !edgeIter.isDone(); edgeIter.next(), nRods++ ) { p0 = edgeIter.point( 0, MSpace::kWorld ); p1 = edgeIter.point( 1, MSpace::kWorld ); // N.B. Generate the uv coordinates only once since they // are referenced by all rods genRod( p0, p1, radius.value(), segs, nRodPolys, rodVerts, rodPolyCounts, rodPolyConnects, nRods == 0, rodUCoords, rodVCoords, rodFvUVIDs ); vertOffset = newVerts.length(); // Add the rod to the mesh nNewPolys += nRodPolys; for( i=0; i < rodVerts.length(); i++ ) newVerts.append( rodVerts[i] ); for( i=0; i < rodPolyCounts.length(); i++ ) newPolyCounts.append( rodPolyCounts[i] ); for( i=0; i < rodPolyConnects.length(); i++ ) newPolyConnects.append( vertOffset + rodPolyConnects[i] ); // First rod if( nRods == 0 ) { // Add rod's uv coordinates to the list for( i=0; i < rodUCoords.length(); i++ ) { newUCoords.append( rodUCoords[i] ); newVCoords.append( rodVCoords[i] ); } } // Set the face-vertex-uvIDs for( i=0; i < rodFvUVIDs.length(); i++ ) { newFvUVIDs.append( uvOffset + rodFvUVIDs[i] ); } } objTransform = meshFn.create( newVerts.length(), nNewPolys, newVerts, newPolyCounts, newPolyConnects, newUCoords, newVCoords, MObject::kNullObj, &stat ); if( !stat ) { MGlobal::displayError( MString( "Unable to create mesh: " ) + stat.errorString() ); return stat; } objTransforms.append( objTransform ); meshFn.assignUVs( newPolyCounts, newFvUVIDs ); meshFn.updateSurface(); // Rename transform node dagFn.setObject( objTransform ); dagFn.setName( "molecule" ); // Put mesh into the initial shading group dagMod.commandToExecute( MString( "sets -e -fe initialShadingGroup " ) + meshFn.name() ); } // Select all the newly created molecule meshes MString cmd( "select -r" ); for( i=0; i < objTransforms.length(); i++ ) { dagFn.setObject( objTransforms[i] ); cmd += " " + dagFn.name(); } dagMod.commandToExecute( cmd ); return dagMod.doIt(); }
MStatus CVstAimCmd::redoIt() { MStatus mStatus; if ( !mStatus ) { setResult( MString( "Cannot parse command line" ) + mStatus.errorString() ); return MS::kFailure; } if ( m_mArgDatabase->isFlagSet( kHelp ) ) { PrintHelp(); } else { // See if there are two object specified MDagPath mDagPath; MSelectionList optSelectionList; // Validate specified items to whole dag nodes { MSelectionList tmpSelectionList; m_mArgDatabase->getObjects( tmpSelectionList ); for ( MItSelectionList sIt( tmpSelectionList, MFn::kDagNode ); !sIt.isDone(); sIt.next() ) { if ( sIt.getDagPath( mDagPath ) ) { optSelectionList.add( mDagPath, MObject::kNullObj, true ); } } } if ( m_mArgDatabase->isFlagSet( "create" ) || optSelectionList.length() >= 2 && m_mArgDatabase->numberOfFlagsUsed() == 0 ) { // Error if there aren't at least two if ( optSelectionList.length() < 2 ) { displayError( GetName() + " needs at least two objects specified or selected when -create is used" ); return MS::kFailure; } // Get name command line arg MString optName; if ( m_mArgDatabase->isFlagSet( "name" ) ) { m_mArgDatabase->getFlagArgument( "name", 0, optName ); } m_undoable = true; m_mDagModifier = new MDagModifier; MObject vstAimObj( m_mDagModifier->MDGModifier::createNode( GetName() ) ); if ( m_mDagModifier->doIt() != MS::kSuccess ) { displayError( MString( "Couldn't create " ) + GetName() + " node" ); m_mDagModifier->undoIt(); delete m_mDagModifier; m_mDagModifier = NULL; m_undoable = false; return MS::kFailure; } m_mDagModifier->renameNode( vstAimObj, optName.length() ? optName : GetName() ); if ( m_mDagModifier->doIt() != MS::kSuccess ) { if ( optName.length() ) { displayWarning( MString( "Couldn't rename newly created vstNode \"" ) + optName + "\"" ); } } // Set options on the newly create vstAim node MFnDependencyNode vstAimFn( vstAimObj ); MPlug sP; MPlug dP; if ( m_mArgDatabase->isFlagSet( kAim ) ) { MVector aim; m_mArgDatabase->getFlagArgument( kAim, 0, aim.x ); m_mArgDatabase->getFlagArgument( kAim, 1, aim.y ); m_mArgDatabase->getFlagArgument( kAim, 2, aim.z ); sP = vstAimFn.findPlug( "aimX" ); sP.setValue( aim.x ); sP = vstAimFn.findPlug( "aimY" ); sP.setValue( aim.y ); sP = vstAimFn.findPlug( "aimZ" ); sP.setValue( aim.z ); } if ( m_mArgDatabase->isFlagSet( kUp ) ) { MVector up; m_mArgDatabase->getFlagArgument( kUp, 0, up.x ); m_mArgDatabase->getFlagArgument( kUp, 1, up.y ); m_mArgDatabase->getFlagArgument( kUp, 2, up.z ); sP = vstAimFn.findPlug( "upX" ); sP.setValue( up.x ); sP = vstAimFn.findPlug( "upY" ); sP.setValue( up.y ); sP = vstAimFn.findPlug( "upZ" ); sP.setValue( up.z ); } // Now connect up the newly created vstAim node MDagPath toAim; optSelectionList.getDagPath( 1, toAim ); const MFnDagNode toAimFn( toAim ); if ( toAim.hasFn( MFn::kJoint ) ) { MPlug joP( toAimFn.findPlug( "jointOrient" ) ); if ( !joP.isNull() ) { MAngle jox, joy, joz; joP.child( 0 ).getValue( jox ); joP.child( 1 ).getValue( joy ); joP.child( 2 ).getValue( joz ); if ( abs( jox.value() ) > FLT_EPSILON || abs( joy.value() ) > FLT_EPSILON || abs( joz.value() ) > FLT_EPSILON ) { mwarn << "Joint orient on node being constrained is non-zero ( " << jox.asDegrees() << " " << joy.asDegrees() << " " << joz.asDegrees() << " ), setting to 0" << std::endl; joP.child( 0 ).setValue( MAngle( 0.0 ) ); joP.child( 1 ).setValue( MAngle( 0.0 ) ); joP.child( 2 ).setValue( MAngle( 0.0 ) ); } } } if ( toAim.hasFn( MFn::kTransform ) ) { MPlug mP( toAimFn.findPlug( "rotateAxis" ) ); if ( !mP.isNull() ) { MAngle rx, ry, rz; mP.child( 0 ).getValue( rx ); mP.child( 1 ).getValue( ry ); mP.child( 2 ).getValue( rz ); if ( abs( rx.value() ) > FLT_EPSILON || abs( ry.value() ) > FLT_EPSILON || abs( rz.value() ) > FLT_EPSILON ) { mwarn << "Rotate Axis on node being constrained is non-zero ( " << rx.asDegrees() << " " << ry.asDegrees() << " " << rz.asDegrees() << " ), setting to 0" << std::endl; mP.child( 0 ).setValue( MAngle( 0.0 ) ); mP.child( 1 ).setValue( MAngle( 0.0 ) ); mP.child( 2 ).setValue( MAngle( 0.0 ) ); } } } MDagPath aimAt; optSelectionList.getDagPath( 0, aimAt ); const MFnDagNode aimAtFn( aimAt ); // toAim.rotateOrder -> vstAim.rotateOrder sP = toAimFn.findPlug( "rotateOrder" ); dP = vstAimFn.findPlug( "rotateOrder" ); m_mDagModifier->connect( sP, dP ); // toAim.translate -> vstAim.translate sP = toAimFn.findPlug( "translate" ); dP = vstAimFn.findPlug( "translate" ); m_mDagModifier->connect( sP, dP ); // toAim.parentMatrix[ instance ] -> vstAim.parentSpace sP = toAimFn.findPlug( "parentMatrix" ); sP = sP.elementByLogicalIndex( toAim.instanceNumber() ); dP = vstAimFn.findPlug( "parentSpace" ); m_mDagModifier->connect( sP, dP ); // aimAt.worldMatrix[ instance ] -> vstAim.aimSpace sP = aimAtFn.findPlug( "worldMatrix" ); sP = sP.elementByLogicalIndex( aimAt.instanceNumber() ); dP = vstAimFn.findPlug( "aimSpace" ); m_mDagModifier->connect( sP, dP ); // vstAim.rotation -> toAim.rotation // These have to be connected individually because Maya plays stupid tricks // with rotateOrder if they aren't sP = vstAimFn.findPlug( "rotateX" ); dP = toAimFn.findPlug( "rotateX" ); m_mDagModifier->connect( sP, dP ); sP = vstAimFn.findPlug( "rotateY" ); dP = toAimFn.findPlug( "rotateY" ); m_mDagModifier->connect( sP, dP ); sP = vstAimFn.findPlug( "rotateZ" ); dP = toAimFn.findPlug( "rotateZ" ); m_mDagModifier->connect( sP, dP ); if ( m_mDagModifier->doIt() != MS::kSuccess ) { displayWarning( MString( GetName() ) + ": Couldn't connect everything when creating" ); } // Save the current selection just in case we want to undo stuff MGlobal::getActiveSelectionList( m_mSelectionList ); MGlobal::select( vstAimObj, MGlobal::kReplaceList ); setResult( vstAimFn.name() ); } else if ( m_mArgDatabase->isFlagSet( "select" ) ) { MSelectionList mSelectionList; MDagPath mDagPath; for ( MItDag dagIt; !dagIt.isDone(); dagIt.next() ) { if ( MFnDependencyNode( dagIt.item() ).typeName() == GetName() ) { dagIt.getPath( mDagPath ); mSelectionList.add( mDagPath, MObject::kNullObj, true ); } } if ( mSelectionList.length() ) { m_undoable = true; // Save the current selection just in case we want to undo stuff MGlobal::getActiveSelectionList( m_mSelectionList ); MGlobal::setActiveSelectionList( mSelectionList, MGlobal::kReplaceList ); } } else { displayError( GetName() + ": No valid operation specified via command line arguments\n" ); } } return MS::kSuccess; }
MStatus HesperisCmd::attachSelected(const Vector3F & offsetV) { MGlobal::displayInfo(MString(" attach to grow mesh ") + m_growMeshName); MSelectionList selList; MGlobal::getActiveSelectionList(selList); MItSelectionList iter( selList ); MDagPath apath; iter.getDagPath( apath ); MObject otrans = apath.node(); if(!otrans.hasFn(MFn::kTransform)) { MGlobal::displayWarning("must select a transform/group to attach to grow mesh"); return MS::kFailure; } ASearchHelper searcher; MDagPath meshGrp; if(!searcher.dagByFullName(m_growMeshName.asChar(), meshGrp)) { MGlobal::displayWarning(MString("cannot find grow mesh by name ")+m_growMeshName); return MS::kFailure; } MObject ogrow = meshGrp.node(); if(!ogrow.hasFn(MFn::kTransform)) { MGlobal::displayWarning("-gm must be a transform/group"); return MS::kFailure; } MStatus stat; MDGModifier modif; MDagModifier dmodif; MObject hestranslate = modif.createNode("hesperisTranslateNode", &stat); modif.doIt(); if(hestranslate.isNull()) { MGlobal::displayWarning("cannot create hes translate node"); return MS::kFailure; } MFnDependencyNode fhest(hestranslate); MFnDependencyNode fgrow(ogrow); modif.connect(fgrow.findPlug("boundingBoxMinX", true), fhest.findPlug("bBoxMinX", true)); modif.connect(fgrow.findPlug("boundingBoxMinY", true), fhest.findPlug("bBoxMinY", true)); modif.connect(fgrow.findPlug("boundingBoxMinZ", true), fhest.findPlug("bBoxMinZ", true)); modif.connect(fgrow.findPlug("boundingBoxMaxX", true), fhest.findPlug("bBoxMaxX", true)); modif.connect(fgrow.findPlug("boundingBoxMaxY", true), fhest.findPlug("bBoxMaxY", true)); modif.connect(fgrow.findPlug("boundingBoxMaxZ", true), fhest.findPlug("bBoxMaxZ", true)); MPlug psrcwpmat = fgrow.findPlug("parentMatrix", true, &stat); if(!stat) MGlobal::displayInfo("cannot find plug worldParentMatrix"); modif.connect(psrcwpmat, fhest.findPlug("inParentMatrix", true)); modif.doIt(); MFnDependencyNode ftrans(otrans); dmodif.connect(fhest.findPlug("outTranslateX", true), ftrans.findPlug("translateX", true)); dmodif.connect(fhest.findPlug("outTranslateY", true), ftrans.findPlug("translateY", true)); dmodif.connect(fhest.findPlug("outTranslateZ", true), ftrans.findPlug("translateZ", true)); stat = dmodif.doIt(); if(!stat) MGlobal::displayInfo(MString("cannot make some connections to ")+ftrans.name()); fhest.findPlug("offsetX").setValue((double)-offsetV.x); fhest.findPlug("offsetY").setValue((double)-offsetV.y); fhest.findPlug("offsetZ").setValue((double)-offsetV.z); return MS::kSuccess; }
void EntityNode::LoadArt() { MStatus stat; bool callbackRemoved = false; if( s_EditNodeAddedCBId != -1 ) { MDGMessage::removeCallback( s_EditNodeAddedCBId ); s_EditNodeAddedCBId = -1; callbackRemoved = true; } UnloadArt(); MString artFilePath; GetArtFilePath( artFilePath ); std::cout << "Importing from: " << artFilePath.asTChar() << "..." << std::endl; // add the callback to catch all the imported objects MObjectArray objectArrays[NodeArrays::Count]; s_ImportNodeAddedCBId = MDGMessage::addNodeAddedCallback( ImportNodeAddedCallback, kDefaultNodeType, &objectArrays ); // import stuff MFileIO::import( artFilePath, NULL, false ); // remove the callback MDGMessage::removeCallback( s_ImportNodeAddedCBId ); // add all imported stuff under this guy's transform MFnDagNode nodeFn( thisMObject() ); for( u32 i=0; i<objectArrays[NodeArrays::KeepNodes].length(); ++i ) { if( objectArrays[NodeArrays::KeepNodes][i].isNull() ) { continue; } MObjectHandle handle( objectArrays[NodeArrays::KeepNodes][i] ); if ( !handle.isValid() ) { continue; } // We should be getting only MFnDagNode in here, but just in case MFnDagNode dagFn( objectArrays[NodeArrays::KeepNodes][i], &stat ); if ( stat == MStatus::kSuccess ) { stat = dagFn.setDoNotWrite( true ); } else { MFnDependencyNode depNodeFn( objectArrays[NodeArrays::KeepNodes][i], &stat ); stat = depNodeFn.setDoNotWrite( true ); } #ifdef _DEBUG MString name = dagFn.name(); MString type = dagFn.typeName(); std::string nodeTypeStr( objectArrays[NodeArrays::KeepNodes][i].apiTypeStr() ); if ( name.length() ) { std::cout << " - Importing Child: " << name.asTChar() << " " << type.asTChar() << "(" << nodeTypeStr << ")" << std::endl; } #endif AddImportNode( objectArrays[NodeArrays::KeepNodes][i] ); nodeFn.addChild( objectArrays[NodeArrays::KeepNodes][i] ); } for( u32 i=0; i<objectArrays[NodeArrays::DeleteNodes].length(); ++i ) { MGlobal::deleteNode( objectArrays[NodeArrays::DeleteNodes][i] ); } MFnDagNode otherFn; for( u32 i=0 ; i<nodeFn.childCount(); ++i ) { MObject child = nodeFn.child( i ); if( !child.hasFn( MFn::kDagNode ) ) { continue; } otherFn.setObject( child ); if( otherFn.typeId() == EntityNode::s_TypeID ) { MDagModifier mod; u32 numChild = otherFn.childCount(); for( u32 j = 0; j < numChild; ++j ) { stat = mod.reparentNode( otherFn.child( j ), thisMObject() ); } mod.doIt(); MGlobal::deleteNode( child ); break; } } std::cout << "Done" << std::endl; }
bool ToMayaLocatorConverter::doConversion( IECore::ConstObjectPtr from, MObject &to, IECore::ConstCompoundObjectPtr operands ) const { ConstCoordinateSystemPtr coordSys = IECore::runTimeCast<const CoordinateSystem>( from ); if ( !coordSys ) { IECore::msg( IECore::Msg::Warning, "ToMayaLocatorConverter::doConversion", "The source object is not an IECore::CoordinateSystem." ); return false; } // check if incoming object is a locator itself MObject locatorObj; if ( to.hasFn( MFn::kLocator ) ) { locatorObj = to; } // check if incoming object is a parent of an existing locator if ( locatorObj.isNull() ) { MFnDagNode fnTo( to ); for ( unsigned i=0; i < fnTo.childCount(); ++i ) { MObject child = fnTo.child( i ); if ( child.hasFn( MFn::kLocator ) ) { locatorObj = child; break; } } } // make a new locator and parent it to the incoming object if ( locatorObj.isNull() ) { if ( !MFnTransform().hasObj( to ) ) { IECore::msg( IECore::Msg::Warning, "ToMayaLocatorConverter::doConversion", "Unable to create a locator as a child of the input object." ); return false; } MDagModifier dagMod; locatorObj = dagMod.createNode( "locator", to ); dagMod.renameNode( locatorObj, coordSys->getName().c_str() ); if ( !dagMod.doIt() ) { IECore::msg( IECore::Msg::Warning, "ToMayaLocatorConverter::doConversion", "Unable to modify the DAG correctly." ); dagMod.undoIt(); return false; } } if ( locatorObj.isNull() ) { IECore::msg( IECore::Msg::Warning, "ToMayaLocatorConverter::doConversion", "Unable to find or create a locator from the input object." ); return false; } MFnDagNode fnLocator( locatorObj ); Imath::M44f m = coordSys->getTransform()->transform(); Imath::V3f s,h,r,t; Imath::extractSHRT(m, s, h, r, t); /// obtain local position and scale from locator MStatus st; MPlug positionPlug = fnLocator.findPlug( "localPositionX", &st ); if ( !st ) return false; positionPlug.setValue(t[0]); positionPlug = fnLocator.findPlug( "localPositionY", &st ); if ( !st ) return false; positionPlug.setValue(t[1]); positionPlug = fnLocator.findPlug( "localPositionZ", &st ); if ( !st ) return false; positionPlug.setValue(t[2]); MPlug scalePlug = fnLocator.findPlug( "localScaleX", &st ); if ( !st ) return false; scalePlug.setValue(s[0]); scalePlug = fnLocator.findPlug( "localScaleY", &st ); if ( !st ) return false; scalePlug.setValue(s[1]); scalePlug = fnLocator.findPlug( "localScaleZ", &st ); if ( !st ) return false; scalePlug.setValue(s[2]); return true; }
MStatus HelixBase_RemoveAllAimConstraints(MObject & helixBase, const char *type) { MStatus status; MFnDagNode this_dagNode(helixBase, &status); if (!status) { status.perror("MFnDagNode::#ctor"); return status; } unsigned int this_childCount = this_dagNode.childCount(&status); bool foundAimConstraint = false; MDagModifier dagModifier; if (!status) { status.perror("MFnDagNode::childCount"); return status; } for(unsigned int i = 0; i < this_childCount; ++i) { MObject child_object = this_dagNode.child(i, &status); if (!status) { if (status == MStatus::kInvalidParameter) { /* * There seems to be a bug in Maya when opening an already existing file that nodes are reported to have children but the MFnDagNode::child will fail */ return MStatus::kSuccess; } status.perror("MFnDagNode::child"); return status; } MFnDagNode child_dagNode(child_object, &status); if (!status) { status.perror("MFnDagNode::#ctor"); return status; } if (child_dagNode.typeName() == "aimConstraint") { foundAimConstraint = true; //std::cerr << "Found an old aimconstraint to delete named: " << child_dagNode.name().asChar() << std::endl; // DEBUG: /*if (child_object.isNull()) { std::cerr << "The object is null! terminating!" << std::endl; return MStatus::kSuccess; }*/ // This is the operation that crashes Maya when creating a "New scene" if (!(status = dagModifier.deleteNode(child_object))) { status.perror("MDagModifier::deleteNode"); return status; } } } // Execute deletion and reset transformation into translation only if (foundAimConstraint) { if (!(status = dagModifier.doIt())) { status.perror("MDagModifier::doIt"); return status; } MFnTransform this_transform(helixBase, &status); if (!status) { status.perror("MFnTransform::#ctor"); return status; } double rotation[] = { 0.0, 0.0, 0.0 }; if (!(status = this_transform.setRotation(rotation, MTransformationMatrix::kXYZ))) { status.perror("MFnTransform::setRotation"); return status; } } return MStatus::kSuccess; }
void atomImport::connectionFailedCallback(MPlug& srcPlug, MPlug& dstPlug, const MString& srcName, const MString& dstName, void* clientData) { // MString output = "Connection failed callback: "; // output += srcName; output += " "; output += dstName; // MGlobal::displayInfo(output); atomEditsHelper* helper = (NULL != clientData) ? (atomEditsHelper*)clientData : NULL; atomNodeNameReplacer* replacer = (NULL != helper) ? helper->fReplacer : NULL; atomTemplateReader* templateReader = (NULL != helper) ? helper->fTemplateReader : NULL; if (NULL != replacer && srcPlug.isNull()) { // Import of the edits didn't find a match for the source name, use the // replacer and see if that helps // if (replaceNameAndFindPlug(srcName,*replacer,srcPlug)) { if (!dstPlug.isNull()) { // we've found the proper source plug to use and we already // had a dest, so connect them up and we're done // MDagModifier mod; mod.connect(srcPlug,dstPlug); return; } } } if (NULL != replacer && dstPlug.isNull()) { // Import of the edits didn't find a match for the dest name, use the // replacer and see if that helps // if (replaceNameAndFindPlug(dstName,*replacer,dstPlug)) { MStringArray dstParts; dstName.split('.', dstParts); if (!checkPlugAgainstTemplate(dstParts[0],dstPlug,templateReader)) return; if (!srcPlug.isNull()) { // we've found the proper dest plug to use and we already // had a source, so connect them up and we're done // MDagModifier mod; mod.connect(srcPlug,dstPlug); return; } } } if (!dstPlug.isNull()) { MObject dstNode = dstPlug.node(); // Check whether the failed connection was to a setDrivenKey curve // if (dstNode.hasFn(MFn::kAnimCurveUnitlessToAngular) || dstNode.hasFn(MFn::kAnimCurveUnitlessToDistance) || dstNode.hasFn(MFn::kAnimCurveUnitlessToTime) || dstNode.hasFn(MFn::kAnimCurveUnitlessToUnitless)) { // If so, create a stand-in driver for that curve // MDagModifier mod; MObject locator = mod.createNode( "locator", MObject::kNullObj ); MFnDependencyNode fnLoc(locator); MStringArray nameParts; srcName.split('.', nameParts); MString leafAttr(nameParts[nameParts.length()-1]); MPlug leafPlug = fnLoc.findPlug(leafAttr); if (!leafPlug.isNull()) { mod.connect(leafPlug,dstPlug); // rename the locator to the name of the original source // so that any subsequent connections will work // fnLoc.setName(nameParts[0]); } } } }
MObject create(Alembic::AbcGeom::ICamera & iNode, MObject & iParent) { Alembic::AbcGeom::ICameraSchema schema = iNode.getSchema(); MString name(iNode.getName().c_str()); MFnCamera fnCamera; MObject obj = fnCamera.create(iParent); fnCamera.setName(name); // we need to read this to determine the film fit Alembic::AbcGeom::CameraSample samp; iNode.getSchema().get(samp); std::size_t numOps = samp.getNumOps(); if (numOps > 0) { std::string hint = samp[0].getHint(); if (hint == "filmFitFill") { fnCamera.setFilmFit(MFnCamera::kFillFilmFit); } else if (hint == "filmFitHorz") { fnCamera.setFilmFit(MFnCamera::kHorizontalFilmFit); } else if (hint == "filmFitVert") { fnCamera.setFilmFit(MFnCamera::kVerticalFilmFit); } else if (hint == "filmFitOver") { fnCamera.setFilmFit(MFnCamera::kOverscanFilmFit); } } if (schema.isConstant()) { // no center of interest fnCamera.setFocalLength(samp.getFocalLength()); fnCamera.setLensSqueezeRatio(samp.getLensSqueezeRatio()); // camera scale might be in the 3x3 // weirdo attrs that are in inches fnCamera.setHorizontalFilmAperture(samp.getHorizontalAperture()/2.54); fnCamera.setVerticalFilmAperture(samp.getVerticalAperture()/2.54); fnCamera.setHorizontalFilmOffset(samp.getHorizontalFilmOffset()/2.54); fnCamera.setVerticalFilmOffset(samp.getVerticalFilmOffset()/2.54); // film fit offset might be in the 3x3 if (samp.getOverScanLeft() == samp.getOverScanRight() && samp.getOverScanTop() == samp.getOverScanBottom() && samp.getOverScanLeft() == samp.getOverScanTop()) { fnCamera.setOverscan(samp.getOverScanLeft() + 1.0); } else { MString warn = iNode.getName().c_str(); warn += " has unsupported overscan values."; MGlobal::displayWarning(warn); } fnCamera.setNearClippingPlane(samp.getNearClippingPlane()); fnCamera.setFarClippingPlane(samp.getFarClippingPlane()); // prescale, film translate H, V, roll pivot H,V, film roll value // post scale might be in the 3x3 fnCamera.setFStop(samp.getFStop()); fnCamera.setFocusDistance(samp.getFocusDistance()); MTime sec(1.0, MTime::kSeconds); fnCamera.setShutterAngle(Alembic::AbcGeom::DegreesToRadians( 360.0 * (samp.getShutterClose()-samp.getShutterOpen()) * sec.as(MTime::uiUnit()) )); for (std::size_t i = 0; i < numOps; ++i) { Alembic::AbcGeom::FilmBackXformOp & op = samp[i]; if (op.getHint() == "filmFitOffs") { double val = op.getChannelValue(0) * samp.getHorizontalAperture() / 5.08; if (val != 0.0) { fnCamera.setFilmFitOffset(val); } else { fnCamera.setFilmFitOffset(op.getChannelValue(1) * samp.getHorizontalAperture() / 5.08); } } else if (op.getHint() == "preScale") { fnCamera.setPreScale(1.0/op.getChannelValue(0)); } else if (op.getHint() == "filmTranslate") { fnCamera.setFilmTranslateH(op.getChannelValue(0)); fnCamera.setFilmTranslateV(op.getChannelValue(1)); } else if (op.getHint() == "postScale") { fnCamera.setPostScale(1.0/op.getChannelValue(0)); } else if (op.getHint() == "cameraScale") { fnCamera.setCameraScale(op.getChannelValue(0)); } } } // extra transform node is unfortuneatly automatically created above the // camera, let's do some reparenting and delete that extra transform MDagPath path; fnCamera.getPath(path); MObject camObj = path.node(); MDagModifier dagMod; dagMod.reparentNode(camObj, iParent); dagMod.doIt(); dagMod.deleteNode(obj); dagMod.doIt(); return camObj; }