// --------------------------------------------------------------------------------------------
void polyModifierCmd::collectNodeState()
// --------------------------------------------------------------------------------------------
{
MStatus status;
// Collect node state information on the given polyMeshShape
//
// - HasHistory (Construction History exists)
// - HasTweaks
// - HasRecordHistory (Construction History is turned on)
//
fDagPath.extendToShape();
MObject meshNodeShape = fDagPath.node();
MFnDependencyNode depNodeFn;
depNodeFn.setObject( meshNodeShape );
MPlug inMeshPlug = depNodeFn.findPlug( "inMesh" );
fHasHistory = inMeshPlug.isConnected();
// Tweaks exist only if the multi "pnts" attribute contains plugs
// which contain non-zero tweak values. Use false, until proven true
// search algorithm.
//
fHasTweaks = false;
MPlug tweakPlug = depNodeFn.findPlug( "pnts" );
if( !tweakPlug.isNull() )
{
// ASSERT: tweakPlug should be an array plug!
//
MAssert( (tweakPlug.isArray()),
"tweakPlug.isArray() -- tweakPlug is not an array plug" );
MPlug tweak;
MFloatVector tweakData;
int i;
int numElements = tweakPlug.numElements();
for( i = 0; i < numElements; i++ )
{
tweak = tweakPlug.elementByPhysicalIndex( i, &status );
if( status == MS::kSuccess && !tweak.isNull() )
{
getFloat3PlugValue( tweak, tweakData );
if( 0 != tweakData.x ||
0 != tweakData.y ||
0 != tweakData.z )
{
fHasTweaks = true;
break;
}
}
}
}
int result;
MGlobal::executeCommand( "constructionHistory -q -tgl", result );
fHasRecordHistory = (0 != result);
}
bool atomImport::replaceNameAndFindPlug(const MString& origName,
atomNodeNameReplacer& replacer,
MPlug& replacedPlug)
{
bool rtn = false;
// get the node name
//
MStringArray nameParts;
origName.split('.', nameParts);
// Perform any necessary replacement
//
MString tmpName(nameParts[0]);
// TODO: type & hierarchy info -- does the replacer store enough info
// to help us find that out since in the case of export edits we don't
// have that info for sources
//
if (replacer.findNode(atomNodeNameReplacer::eDag,tmpName,0,0)) {
MString newName(tmpName);
newName += (".");
// add the attribute name(s) back on again
//
unsigned int ii;
MString attrName;
for (ii = 1; ii < nameParts.length(); ++ii) {
if (ii > 1) {
attrName += (".");
}
attrName += nameParts[ii];
}
newName += attrName;
MSelectionList tmpList;
if (MS::kSuccess == tmpList.add(newName)) {
tmpList.getPlug(0,replacedPlug);
rtn = !replacedPlug.isNull();
if (!rtn) {
// test for the special case of the pivot component
//
MDagPath path;
MObject component;
if (MS::kSuccess == tmpList.getDagPath(0,path,component) &&
component.apiType() == MFn::kPivotComponent)
{
MObject node;
tmpList.getDependNode(0,node);
MFnDependencyNode fnNode(node);
replacedPlug = fnNode.findPlug(attrName,false);
rtn = !replacedPlug.isNull();
}
}
}
}
return rtn;
}
MStatus liqLightNodeBehavior::connectNodeToNode( MObject &sourceNode, MObject &destinationNode, bool force )
{
//CM_TRACE_FUNC("liqLightNodeBehavior::connectNodeToNode("<<sourceNode.apiTypeStr()<<","<< destinationNode.apiTypeStr()<<","<<force<<")");
MStatus result = MS::kFailure;
MFnDependencyNode src(sourceNode);
if (src.typeName() == "liquidLight")
{
// if we are dragging from a liquidLight
// than we want to see what we are dragging onto
if( true )//destinationNode.hasFn(MFn::kLight))
{
/* if the user is dragging onto a light
then make the connection from the worldMesh
to the dirtyShader plug on the slopeShader */
MFnDependencyNode dest(destinationNode);
MPlug srcPlug = src.findPlug("assignedObjects");
MPlug destPlug = dest.findPlug("liquidLightShaderNode");
if ( destPlug.isNull() )
{
/* the attribute does not exist yet : create it ! */
//cout <<"need to create liquidLightShaderNode attribute on "<<dest.name()<<"..."<<endl;
MString mel = "addAttr -at message -ln liquidLightShaderNode " + dest.name() +";";
result = MGlobal::executeCommand(mel);
if ( result == MS::kSuccess )
{
//cout <<"attribute liquidLightShaderNode successfully created"<<endl;
result = MS::kFailure;
destPlug = dest.findPlug("liquidLightShaderNode");
}
}
if(!srcPlug.isNull() && !destPlug.isNull())
{
MString boolean = (force)? "true":"false";
MString cmd = "connectAttr ";
//cmd += "-force " + boolean + " ";
cmd += srcPlug.name() + " ";
cmd += destPlug.name();
result = MGlobal::executeCommand(cmd);
}
}
}
//if ( result == MS::kSuccess ) cout <<"connection successfull"<<endl;
//else cout <<"connection failed !"<<endl;
return result;
}
void GetDisplacement(MObject& obj,
float& dispPadding,
bool& enableAutoBump)
{
MFnDependencyNode dNode(obj);
MPlug plug = dNode.findPlug("aiDisplacementPadding");
if (!plug.isNull())
dispPadding = MAX(dispPadding, plug.asFloat());
if (!enableAutoBump)
{
plug = dNode.findPlug("aiDisplacementAutoBump");
if (!plug.isNull())
enableAutoBump = enableAutoBump || plug.asBool();
}
}
void AttributeParser::parseMatrixAttribute(MFnDependencyNode & node, MObject & attribute)
{
MStatus status;
MFnMatrixAttribute fnMatrixAttribute(attribute, &status);
if (!status) return;
MPlug plug = node.findPlug(attribute, &status);
if (!status) return;
MPlugArray plugArray;
bool hasConnection = plug.connectedTo(plugArray, true, false, &status);
if (!status) return;
if (hasConnection)
{
MPlug externalPlug = plugArray[0];
bool externalPlugNull = externalPlug.isNull(&status);
if (!status) return;
if (!externalPlugNull)
{
MFnAttribute fnAttribute(attribute, &status);
if (!status) return;
MString name = fnAttribute.name(&status);
if (!status) return;
//MObject pluggedObject = externalPlug.node(&status);
//if (!status) return;
// TODO pass matrix to callback? onMatrix(...) instead of onConnection(...)?
onConnection(plug, name, externalPlug);
}
}
}
HRESULT FxAttributeFiller::EnumParameter(LPD3DXEFFECT pEffect, DXCCEffectPath& parameter, BOOL& GoDeeper, BOOL& DoPost)
{
HRESULT hr= S_OK;
MStatus stat= MS::kSuccess;
MFnDependencyNode depNode(Shader->GetSite());
MPlug Plug;
Plug= Shader->DecodePlug( Shader->TranscodeHandleToPlug( CStringA(parameter.End->LongPathName) ) );
if(Plug.isNull())
return E_FAIL;
FillPlug(parameter, Plug);
FillScript(parameter, Plug);
//e_Exit:
return hr;
}
MStatus ParameterisedHolder<B>::setParameterisedValue( ParameterPtr pa )
{
MPlug p = parameterPlug( pa );
if( p.isNull() )
{
return MStatus::kFailure;
}
MStatus s = MS::kSuccess;
try
{
s = IECoreMaya::ParameterHandler::setValue( p, pa );
if( s )
{
m_dirtyParameters.erase( pa );
}
}
catch ( std::exception &e )
{
msg( Msg::Error, "ParameterisedHolder::setParameterisedValues", boost::format( "Caught exception while setting parameter value from %s : %s" ) % p.name().asChar() % e.what());
s = MS::kFailure;
}
catch (...)
{
msg( Msg::Error, "ParameterisedHolder::setParameterisedValues", boost::format( "Caught exception while setting parameter value from %s" ) % p.name().asChar());
s = MS::kFailure;
}
return s;
}
static bool
_GetMetadataUnchecked(
const MFnDependencyNode& node,
const TfToken& key,
VtValue* value)
{
VtValue fallback = SdfSchema::GetInstance().GetFallback(key);
if (fallback.IsEmpty()) {
return false;
}
std::string mayaAttrName = _GetMayaAttrNameForMetadataKey(key);
MPlug plug = node.findPlug(mayaAttrName.c_str());
if (plug.isNull()) {
return false;
}
TfType ty = fallback.GetType();
VtValue result = UsdMayaWriteUtil::GetVtValue(plug, ty, TfToken());
if (result.IsEmpty()) {
TF_RUNTIME_ERROR(
"Cannot convert plug '%s' into metadata '%s' (%s)",
plug.name().asChar(),
key.GetText(),
ty.GetTypeName().c_str());
return false;
}
*value = result;
return true;
}
//############################################### tima:
bool polyModifierCmd::setZeroTweaks()
{
MFnNumericData numDataFn;
MObject nullVector;
MFnDependencyNode depNodeFn;
numDataFn.create( MFnNumericData::k3Float );
numDataFn.setData( 0, 0, 0 );
nullVector = numDataFn.object();
MObject object = fDagPath.node();
depNodeFn.setObject( object);
MPlug meshTweakPlug = depNodeFn.findPlug( "pnts" );
MPlug tweak;
unsigned numTweaks = fTweakIndexArray.length();
if( !meshTweakPlug.isNull() )
{
for( unsigned i = 0; i < numTweaks; i++ )
{
tweak = meshTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
tweak.setValue( nullVector );
}
}
return true;
}
TheaSDK::Normal3D TheaRenderer::getSunDirection()
{
MFnDependencyNode depFn(getRenderGlobalsNode());
std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr;
std::shared_ptr<TheaRenderer> renderer = std::static_pointer_cast<TheaRenderer>(MayaTo::getWorldPtr()->worldRendererPtr);
TheaSDK::Normal3D sunDir;
MObjectArray nodeList;
getConnectedInNodes(MString("sunLightConnection"), getRenderGlobalsNode(), nodeList);
if( nodeList.length() > 0)
{
MVector lightDir(0,0,1);
MFnDagNode sunDagNode(nodeList[0]);
//lightDir *= this->mtth_renderGlobals->globalConversionMatrix.inverse();
lightDir *= sunDagNode.transformationMatrix();
lightDir *= renderGlobals->globalConversionMatrix;
lightDir.normalize();
return TheaSDK::Normal3D(lightDir.x,lightDir.y,lightDir.z);
}
float sunDirX = 0.0f, sunDirY = 0.0f, sunDirZ = 1.0f;
MPlug sunDirPlug = depFn.findPlug("sunDirection");
if (!sunDirPlug.isNull())
{
sunDirX = sunDirPlug.child(0).asFloat();
sunDirY = sunDirPlug.child(1).asFloat();
sunDirZ = sunDirPlug.child(2).asFloat();
}
return TheaSDK::Normal3D(sunDirX, sunDirY, sunDirZ);
}
MObject getOtherSideSourceNode(MString& plugName, MObject& thisObject, bool checkChildren, MString& outPlugName)
{
MStatus stat;
MObject result = MObject::kNullObj;
MFnDependencyNode depFn(thisObject, &stat); if (stat != MStatus::kSuccess) return result;
MPlugArray pa;
depFn.getConnections(pa);
MPlug connectedPlug;
for (uint pId = 0; pId < pa.length(); pId++)
{
MPlug plug = pa[pId];
if (!plug.isDestination())
continue;
while (plug.isChild())
{
plug = plug.parent();
}
if (getAttributeNameFromPlug(plug) == plugName)
{
connectedPlug = pa[pId];
}
}
if (connectedPlug.isNull())
return result;
connectedPlug.connectedTo(pa, true, false, &stat); if (stat != MStatus::kSuccess) return result;
if (pa.length() == 0)
return result;
MPlug otherSidePlug = pa[0];
result = otherSidePlug.node();
outPlugName = getAttributeNameFromPlug(otherSidePlug);
if (otherSidePlug.isChild())
outPlugName = getAttributeNameFromPlug(otherSidePlug.parent());
return result;
}
// alembic by default sets meshes to be poly unless it's explicitly set to be
// subdivision. UsdExport makes meshes catmullClark by default. Here, we
// implement logic to get set the subdivision scheme so that it matches.
static
void
_SetMeshesSubDivisionScheme(
UsdStagePtr stage,
const UsdMayaChaserRegistry::FactoryContext::DagToUsdMap& dagToUsd)
{
for (const auto& p: dagToUsd) {
const MDagPath& dag = p.first;
const SdfPath& usdPrimPath = p.second;
if (!dag.isValid()) {
continue;
}
MStatus status;
MFnMesh meshFn(dag, &status);
if (!status) {
continue;
}
if (UsdGeomMesh usdMesh = UsdGeomMesh::Get(stage, usdPrimPath)) {
MPlug plug = meshFn.findPlug("SubDivisionMesh");
bool isSubDivisionMesh = (!plug.isNull() && plug.asBool());
if (!isSubDivisionMesh) {
usdMesh.GetSubdivisionSchemeAttr().Set(UsdGeomTokens->none);
}
}
}
}
MObject findShader(MObject& setNode, SXRShaderData& d)
//
// Description:
// Find the shading node for the given shading group set node.
//
{
MFnDependencyNode fnNode(setNode);
d.name = fnNode.name();
// cout << "looking for shader in node " << fnNode.name().asChar() << "\n";
MPlug shaderPlug = fnNode.findPlug("surfaceShader");
if (!shaderPlug.isNull()) {
MPlugArray connectedPlugs;
bool asSrc = false;
bool asDst = true;
shaderPlug.connectedTo( connectedPlugs, asDst, asSrc );
if (connectedPlugs.length() != 1)
Msg("!Error getting shader");
else
return connectedPlugs[0].node();
}
Msg("!Error finding surface shader for node '%s'",fnNode.name().asChar());
return MObject::kNullObj;
}
MStatus liqLightNodeBehavior::connectNodeToAttr( MObject &sourceNode, MPlug &destinationPlug, bool force )
{
//CM_TRACE_FUNC("liqLightNodeBehavior::connectNodeToAttr("<<sourceNode.apiTypeStr()<<","<< destinationPlug.name()<<","<<force<<")");
MStatus result = MS::kFailure;
MFnDependencyNode src(sourceNode);
/*
if we are dragging from a liquidLight
to a light then connect the assignedObjects
plug to the plug being passed in
*/
if(destinationPlug.node().hasFn(MFn::kLight))
{
if(src.typeName() == "liquidLight")
{
MPlug srcPlug = src.findPlug("assignedObjects");
MObject dstNode = destinationPlug.node();
MFnDependencyNode dst( dstNode );
MPlug dstPlug = dst.findPlug("liquidLightShaderNode");
if(!srcPlug.isNull() && !destinationPlug.isNull() && destinationPlug == dstPlug )
{
//MString boolean = (force)? "true":"false";
MString cmd = "connectAttr ";
//cmd += "-force " + boolean + " ";
cmd += srcPlug.name() + " ";
cmd += destinationPlug.name();
result = 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();
result = connectNodeToNode(sourceNode, destinationNode, force);
}
return result;
}
MStatus unShowAvailableSystems::findAvailableSystems(std::string& str,MDagPath& dagPath)
{
MStatus stat = MS::kSuccess;
if(dagPath.hasFn(MFn::kJoint))
{
MFnIkJoint jointFn(dagPath);
std::string name = dagPath.partialPathName().asChar();
MPlug plug = jointFn.findPlug("unRibbonEnabled");
if(!plug.isNull())
{
bool enabled;
plug.getValue(enabled);
char s[256];
sprintf(s,"%s RibbonSystem %s\n",name.c_str(),enabled ? "True" : "False");
str += s;
}
plug = jointFn.findPlug("unParticleEnabled");
if(!plug.isNull())
{
bool enabled;
plug.getValue(enabled);
char s[256];
sprintf(s,"%s ParticleSystem %s\n",name.c_str(),enabled ? "True" : "False");
str += s;
}
}
for (unsigned int i = 0; i < dagPath.childCount(); i++)
{
MObject child = dagPath.child(i);
MDagPath childPath;
stat = MDagPath::getAPathTo(child,childPath);
if (MS::kSuccess != stat)
{
return MS::kFailure;
}
stat = findAvailableSystems(str,childPath);
if (MS::kSuccess != stat)
return MS::kFailure;
}
return MS::kSuccess;
}
IECore::ParameterPtr ParameterisedHolder<B>::plugParameter( const MPlug &plug )
{
assert( ! plug.isNull() );
// to update the parameter->name map if necessary
getParameterised();
AttributeNameToParameterMap::const_iterator it = m_attributeNamesToParameters.find( plug.partialName() );
if( it==m_attributeNamesToParameters.end() )
{
return 0;
}
return it->second;
}
MayaTransformWriter::MayaTransformWriter(double iFrame,
MayaTransformWriter & iParent, MDagPath & iDag,
uint32_t iTimeIndex,
bool iWriteVisibility)
{
if (iDag.hasFn(MFn::kJoint))
{
MFnIkJoint joint(iDag);
Alembic::AbcGeom::OXform obj(iParent.getObject(), joint.name().asChar(),
iTimeIndex);
mSchema = obj.getSchema();
Alembic::Abc::OCompoundProperty cp = obj.getProperties();
mAttrs = AttributesWriterPtr(new AttributesWriter(iFrame, cp, joint,
iTimeIndex, iWriteVisibility));
pushTransformStack(iFrame, joint);
}
else
{
MFnTransform trans(iDag);
Alembic::AbcGeom::OXform obj(iParent.getObject(), trans.name().asChar(),
iTimeIndex);
mSchema = obj.getSchema();
Alembic::Abc::OCompoundProperty cp = obj.getProperties();
mAttrs = AttributesWriterPtr(new AttributesWriter(iFrame, cp, trans,
iTimeIndex, iWriteVisibility));
pushTransformStack(iFrame, trans);
}
// need to look at inheritsTransform
MFnDagNode dagNode(iDag);
MPlug inheritPlug = dagNode.findPlug("inheritsTransform");
if (!inheritPlug.isNull())
{
if (util::getSampledType(inheritPlug) != 0)
mInheritsPlug = inheritPlug;
mSample.setInheritsXforms(inheritPlug.asBool());
}
// everything is default, don't write anything
if (mSample.getNumOps() == 0 && mSample.getInheritsXforms())
return;
mSchema.set(mSample);
}
//-----------------------------------------------------------------------------
// Returns the node MObject that is connected as an input to the specified attribute on the specified node
//-----------------------------------------------------------------------------
MObject ValveMaya::FindInputNode( const MObject &dstNodeObj, const MString &dstPlugName )
{
const MFnDependencyNode dstNodeFn( dstNodeObj );
const MPlug dstPlug( dstNodeFn.findPlug( dstPlugName ) );
if ( dstPlug.isNull() )
return MObject::kNullObj;
MPlugArray mPlugArray;
if ( !( dstPlug.connectedTo( mPlugArray, true, false ) && mPlugArray.length() ) )
return MObject::kNullObj;
return mPlugArray[ 0 ].node();
}
MStatus slopeShaderBehavior::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.
//
{
MStatus result = MS::kFailure;
MFnDependencyNode src(sourceNode);
//if we are dragging from a slopeShader
//to a shader than connect the outColor
//plug to the plug being passed in
//
if(destinationPlug.node().hasFn(MFn::kLambert)) {
if(src.typeName() == "slopeShader")
{
MPlug srcPlug = src.findPlug("outColor");
if(!srcPlug.isNull() && !destinationPlug.isNull())
{
MString cmd = "connectAttr ";
cmd += srcPlug.name() + " ";
cmd += destinationPlug.name();
result = 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();
result = connectNodeToNode(sourceNode, destinationNode, force);
}
return result;
}
void AttributeParser::parseMeshData(MFnDependencyNode & node, MObject & attr)
{
MStatus status;
MPlug plug = node.findPlug(attr, &status);
if (!status) return;
MObject meshNode;
MPlugArray plugArray;
bool success = plug.connectedTo(plugArray, true, false, &status);
if (!status) return;
if (success)
{
MPlug extPlug = plugArray[0];
bool hasConnection = !extPlug.isNull(&status);
if (!status) return;
if (hasConnection)
{
meshNode = extPlug.node(&status);
if (!status) return;
}
}
/*
MDataHandle dataHandle;
status = plug.getValue(dataHandle);
if (!status) return;
MObject meshData;
status = plug.getValue(meshData);
if (!status) return;
MFnMesh fnMesh(meshData, &status);
if (!status) return;
MDagPath dagPath = fnMesh.dagPath(&status);
if (!status) return;
MObject meshNode = dagPath.node(&status);
*/
MFnAttribute fnAttr(attr, &status);
if (!status) return;
MString name = fnAttr.name(&status);
if (!status) return;
onMesh(plug, name, meshNode);
}
std::vector<MObject> lrutils::buildSkeletonFromGuide(std::vector<MVectorArray> locations, MString prefix, MPlug metaDataPlug, MObject metaParentJoint, MString layerName) {
MDGModifier dgMod;
MStatus status;
std::vector<MObject> joints;
MFnMessageAttribute mAttr;
MObject parentJoint;
unsigned int jointNum = 0;
for (std::vector<MVectorArray>::iterator it = locations.begin(); it != locations.end(); ++it) {
MVectorArray location = *it;
MObject joint = createJointFromLocation(location, prefix, jointNum, parentJoint);
joints.push_back(joint);
MFnTransform jointFn( joint );
//add metaParent attributes to joint
if(!metaDataPlug.isNull()) {
MObject jointAttr = mAttr.create("metaParent", "metaParent");
jointFn.addAttribute(jointAttr);
//connect the metaparent attribute to the MDSpine node
status = dgMod.connect( metaDataPlug, jointFn.findPlug("metaParent") );
MyCheckStatus(status, "connect failed");
dgMod.doIt();
}
//if layer name is provided, add the joint to that display layer
if(layerName != "") {
MGlobal::executeCommand("editDisplayLayerMembers -noRecurse "+ layerName+" "+ jointFn.name()+";");
}
parentJoint = joint;
jointNum++;
}
//orient the joint chain
MFnTransform topJointFn(joints.at(0));
MGlobal::executeCommand("joint -e -zso -oj \"xyz\" -sao \"yup\" -ch " + topJointFn.fullPathName() + ";");
//if meta parent joint is not null, parent first joint to it
if(!metaParentJoint.isNull()) {
MFnTransform firstJointFn(joints.at(0));
MFnTransform metaParentJointFn(metaParentJoint);
MGlobal::executeCommand("parent " + firstJointFn.fullPathName() + " " + metaParentJointFn.fullPathName() + ";");
//orient the parent joint
MGlobal::executeCommand("joint -e -zso -oj \"xyz\" -sao \"yup\" -ch " + metaParentJointFn.fullPathName() + ";");
}
return joints;
}
int tm_polygon::removeTweaks_Func( MSelectionList &selectionList)
{
MStatus status;
MObject object;
status = selectionList.getDependNode( 0, object);
if(!status)
{
MGlobal::displayError("***### tm_polygon: Can't find object.");
return 0;
}
MFnMesh mesh( object, &status);
if(!status)
{
MGlobal::displayError("***### tm_polygon: Can't find mesh.");
return 0;
}
int pntsCount = 0;
MPlug pntsPlug = mesh.findPlug( "pnts" );
if( !pntsPlug.isNull() )
{
MPlug tweakPlug;
MObject nullVector_object;
MFnNumericData numDataFn( nullVector_object );
// numDataFn.setData3Double( 0.0, 0.0, 0.0 );
numDataFn.setData( 0.0, 0.0, 0.0 );
pntsCount = pntsPlug.numElements();
for( int i = 0; i < pntsCount; i++ )
{
tweakPlug = pntsPlug.elementByPhysicalIndex( (unsigned int)i, &status );
if( status == MS::kSuccess && !tweakPlug.isNull() )
tweakPlug.setValue( nullVector_object );
}
}
return pntsCount;
}
MStatus ParameterisedHolder<B>::setDependentsDirty( const MPlug &plug, MPlugArray &plugArray )
{
if( plug==aParameterisedClassName || plug==aParameterisedVersion || plug==aParameterisedSearchPathEnvVar )
{
// if the held class changes in any way then we ditch it so we're forced to reload
// in getParameterised().
m_parameterised = 0;
m_failedToLoad = false;
}
else
{
// if the plug represents a parameter then we add that parameter to a list
// of dirty parameters. this lets us optimise setParameterisedValues so we only
// set the values of parameters whose plugs have changed since last time.
// we only bother doing this if we've loaded the class already, as calling plugParameter()
// would otherwise cause a premature loading of the class. when we load the class all parameters
// are marked as dirty anyway so there's no point worrying about it here.
if( m_parameterised )
{
MPlug p = plug;
ParameterPtr parameter = 0;
do
{
parameter = plugParameter( p );
if( p.isChild() )
{
p = p.parent();
}
else if( p.isElement() )
{
p = p.array();
}
else
{
p = MPlug();
}
} while( !parameter && !p.isNull() );
if( parameter )
{
m_dirtyParameters.insert( parameter );
}
}
}
return B::setDependentsDirty( plug, plugArray );
}
void NifKFAnimationImporter::ImportAnimation( NiInterpolatorRef interpolator,MString& targetObject ) {
MObject object = this->GetObjectByName(targetObject);
if(object.isNull()) {
return;
}
vector<Key<Vector3>> translationKeys;
vector<Key<float>> scaleKeys;
vector<Key<Quaternion>> rotationQuaternionKeys;
vector<Key<float>> rotationXKeys;
vector<Key<float>> rotationYKeys;
vector<Key<float>> rotationZKeys;
MFnTransform transformNode(object);
MPlug plug = transformNode.findPlug("interpolatorType");
MString node_name = transformNode.name();
MString mel_command = "addAttr -dataType \"string\" -shortName \"interpolatorType\" ";
if(plug.isNull()) {
MGlobal::executeCommand(mel_command + node_name);
}
if(interpolator->GetType().IsSameType(NiTransformInterpolator::TYPE)) {
NiTransformInterpolatorRef transformInterpolator = DynamicCast<NiTransformInterpolator>(interpolator);
NiTransformDataRef transformData = transformInterpolator->GetData();
if(transformData != NULL) {
if(transformData->GetRotateType() == KeyType::XYZ_ROTATION_KEY) {
rotationXKeys = transformData->GetXRotateKeys();
rotationYKeys = transformData->GetYRotateKeys();
rotationZKeys = transformData->GetZRotateKeys();
} else {
rotationQuaternionKeys = transformData->GetQuatRotateKeys();
}
translationKeys = transformData->GetTranslateKeys();
scaleKeys = transformData->GetScaleKeys();
}
mel_command = "setAttr -type \"string\" ";
MGlobal::executeCommand(mel_command + node_name + "\.interpolatorType \"NiTransformInterpolator\"");
}
MObject Material::findShader(MObject &setNode) {
MFnDependencyNode fnNode(setNode);
MPlug shaderPlug = fnNode.findPlug("surfaceShader");
if (!shaderPlug.isNull()) {
MPlugArray connectedPlugs;
bool asSrc = false;
bool asDst = true;
shaderPlug.connectedTo( connectedPlugs, asDst, asSrc );
if (connectedPlugs.length() != 1)
cerr << "Error getting shader\n";
else
return connectedPlugs[0].node();
}
return MObject::kNullObj;
}
MStatus OpHolder<B>::setDependentsDirty( const MPlug &plug, MPlugArray &plugArray )
{
/// This isn't the best way of doing it, but at this point we can't even be sure that the Op has been loaded,
/// so calling plugParameter() may not work. We can't call getOp() or getParameterised() here, as it seems
/// we can't do things such as adding/removing attributes within this function
if( std::string( plug.partialName().substring( 0, 4 ).asChar() ) == ParameterisedHolder<B>::g_attributeNamePrefix || plug==aResultDependency )
{
MFnDependencyNode fnDN( B::thisMObject() );
MStatus s;
MPlug resultPlug = fnDN.findPlug( "result" , &s);
if ( s && !resultPlug.isNull() )
{
plugArray.append( resultPlug );
}
}
return ParameterisedHolder<B>::setDependentsDirty( plug, plugArray );
}
/// Returns the arnold shader to assign to the procedural.
AtNode *arnoldShader()
{
bool overrideShaders = false;
MPlug plug = FindMayaObjectPlug( "overrideProceduralShaders" );
if( !plug.isNull() )
{
// if we've been told explicitly not to override the shaders
// in the procedurals, then early out.
overrideShaders = plug.asBool();
if( !overrideShaders )
{
return 0;
}
}
unsigned instNumber = m_dagPath.isInstanced() ? m_dagPath.instanceNumber() : 0;
MPlug shadingGroupPlug = GetNodeShadingGroup(m_dagPath.node(), instNumber);
if( !overrideShaders )
{
// if we weren't explicitly told to override the shaders, then
// decide whether to or not based on whether a non-default
// shader has been applied to the shape by the user.
MObject shadingGroupNode = shadingGroupPlug.node();
MFnDependencyNode fnShadingGroupNode( shadingGroupNode );
if( fnShadingGroupNode.name() != "initialShadingGroup" )
{
overrideShaders = true;
}
}
if( overrideShaders )
{
return ExportNode( shadingGroupPlug );
}
else
{
return 0;
}
}
//
// Utility method to retrieve from a node its color space attribute.
//
const MString colorTransformDataTranslator::getInputColorSpace(const MObject& object)
{
MString inputColorSpace;
if(!object.isNull() &&
( (object.apiType()==MFn::kFileTexture) || (object.apiType()==MFn::kImagePlane) ) )
{
MStatus status;
MFnDependencyNode texNode(object, &status);
if(status)
{
static const char* const colorSpaceStr = "colorSpace";
MPlug plug = texNode.findPlug(colorSpaceStr, &status);
if (status && !plug.isNull())
{
plug.getValue(inputColorSpace);
}
}
}
return inputColorSpace;
}
/* static */
bool
UsdMayaTranslatorMesh::_AssignConstantPrimvarToMesh(
const UsdGeomPrimvar& primvar,
MFnMesh& meshFn)
{
const TfToken& interpolation = primvar.GetInterpolation();
if (interpolation != UsdGeomTokens->constant) {
return false;
}
const TfToken& name = primvar.GetBaseName();
const SdfValueTypeName& typeName = primvar.GetTypeName();
const SdfVariability& variability = SdfVariabilityUniform;
MObject attrObj =
UsdMayaReadUtil::FindOrCreateMayaAttr(
typeName,
variability,
meshFn,
name.GetText());
if (attrObj.isNull()) {
return false;
}
VtValue primvarData;
primvar.Get(&primvarData);
MStatus status;
MPlug plug = meshFn.findPlug(
name.GetText(),
/* wantNetworkedPlug = */ true,
&status);
if (status != MS::kSuccess || plug.isNull()) {
return false;
}
return UsdMayaReadUtil::SetMayaAttr(plug, primvarData);
}
MObject findShader( MObject& setNode )
//
// Description:
// Find the shading node for the given shading group set node.
//
{
MFnDependencyNode fnNode(setNode);
MPlug shaderPlug = fnNode.findPlug("surfaceShader");
if (!shaderPlug.isNull()) {
MPlugArray connectedPlugs;
bool asSrc = false;
bool asDst = true;
shaderPlug.connectedTo( connectedPlugs, asDst, asSrc );
if (connectedPlugs.length() != 1)
MGlobal::displayError("Error getting shader");
else
return connectedPlugs[0].node();
}
return MObject::kNullObj;
}
