void EntityNode::UnloadArt()
{
MStatus stat;
// remove anything currently imported/referenced
MFnDagNode dagFn( thisMObject() );
while( dagFn.childCount() )
{
stat = MGlobal::deleteNode( dagFn.child( 0 ) );
MContinueErr( stat, ("Unable to delete" + dagFn.fullPathName() ).asChar() );
}
ClearInstances();
MObjectArray forDelete;
GetImportNodes( forDelete );
MFnDependencyNode depFn;
u32 num = forDelete.length();
for( u32 i = 0; i < num; ++i )
{
MObject& node = forDelete[i];
MObjectHandle handle( node );
if( !handle.isValid() )
continue;
depFn.setObject( node );
stat = MGlobal::deleteNode( node );
MContinueErr( stat, ("Unable to delete" + depFn.name() ).asChar() );
}
forDelete.clear();
}
MStatus skinClusterWeights::undoIt()
{
MStatus status;
for (unsigned i = 0; i < fDagPathArray.length(); i++) {
MDagPath &dagPath = fDagPathArray[i];
MObject skinCluster = findSkinCluster(dagPath);
if (!isSkinClusterIncluded(skinCluster)) {
continue;
}
MFnSkinCluster skinClusterFn(skinCluster, &status);
if (status != MS::kSuccess) {
continue;
}
MObject &component = fComponentArray[i];
if (dagPath.isValid() &&
fInfluenceIndexArrayPtrArray[i].length() > 0 && fWeightsPtrArray[i].length() > 0) {
skinClusterFn.setWeights(dagPath, component, fInfluenceIndexArrayPtrArray[i], fWeightsPtrArray[i]);
}
}
fDagPathArray.clear();
fComponentArray.clear();
delete [] fInfluenceIndexArrayPtrArray;
delete [] fWeightsPtrArray;
fInfluenceIndexArrayPtrArray = NULL;
fWeightsPtrArray = NULL;
return MS::kSuccess;
}
MStatus GetSelectedObjectsOfType(MObjectArray & objects, MTypeId & type) {
MStatus status;
MSelectionList selectionList;
if (!(status = MGlobal::getActiveSelectionList(selectionList))) {
status.perror("MGlobal::getActiveSelectionList");
return status;
}
if (!(status = objects.clear())) {
status.perror("MObjectArray::clear");
return status;
}
unsigned int selectionList_length = selectionList.length(&status);
if (!status) {
status.perror("MSelectionList::length");
return status;
}
for(unsigned int i = 0; i < selectionList_length; ++i) {
//MDagPath dagPath;
MObject object;
if (!(status = selectionList.getDependNode(i, object))) {
status.perror("MSelectionList::getDependNode");
return status;
}
MObject relative = GetObjectOrParentsOfType(object, type, status);
if (!status) {
status.perror("GetObjectOrParentsOfType");
return status;
}
if (relative != MObject::kNullObj) {
/*
* Make sure it's not already added
*/
bool contains = false;
for(unsigned int i = 0; i < objects.length(); ++i) {
if (objects[i] == object) {
contains = true;
break;
}
}
if (!contains)
objects.append(relative);
}
}
return MStatus::kSuccess;
}
// --------------------------------------
void ReferenceManager::getRootObjects(
const MObject& referenceNode,
MDagPathArray& rootPaths,
MObjectArray& subReferences)
{
rootPaths.clear();
subReferences.clear();
MFnDependencyNode referenceNodeFn(referenceNode);
// Get the paths of all the dag nodes included in this reference
MStringArray nodeNames;
MString command = MString("reference -rfn \"") + referenceNodeFn.name() + "\" -q -node -dp;";
MGlobal::executeCommand(command, nodeNames);
uint nodeNameCount = nodeNames.length();
MDagPathArray nodePaths;
for (uint j = 0; j < nodeNameCount; ++j)
{
MObject o = DagHelper::getNode(nodeNames[j]);
MDagPath p = DagHelper::getShortestDagPath(o);
if (p.length() > 0)
{
nodePaths.append(p);
}
else
{
if (o != MObject::kNullObj && o.apiType() == MFn::kReference
&& strstr(nodeNames[j].asChar(), "_UNKNOWN_REF_NODE") == NULL)
{
subReferences.append(o);
}
}
}
// Keep only the root transform for the reference in our path arrays
uint nodePathCount = nodePaths.length();
for (uint j = 0; j < nodePathCount; ++j)
{
const MDagPath& p = nodePaths[j];
if ( !isRootTransform ( nodePaths, p ) ) continue;
rootPaths.append(p);
}
}
void geometrySurfaceConstraint::getOutputAttributes(MObjectArray& attributeArray)
{
attributeArray.clear();
attributeArray.append( geometrySurfaceConstraint::constraintGeometry );
}
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 SelectedBases(MObjectArray & result) {
MStatus status;
MSelectionList selectionList;
if (!(status = MGlobal::getActiveSelectionList(selectionList))) {
status.perror("MGlobal::getActiveSelectionList");
return status;
}
if (!(status = result.clear())) {
status.perror("MDagPathArray::clear");
return status;
}
unsigned int selectionList_length = selectionList.length(&status);
if (!status) {
status.perror("MSelectionList::length");
return status;
}
for(unsigned int i = 0; i < selectionList_length; ++i) {
MObject depNode;
if (!(status = selectionList.getDependNode(i, depNode))) {
status.perror("MSelectionList::getDependNode");
return status;
}
MFnDagNode dagNode(depNode);
if (dagNode.typeId(&status) == HelixBase::id)
result.append(depNode);
else {
// This is not a HelixBase, but it's parent might be?
unsigned int parentCount = dagNode.parentCount(&status);
if (!status) {
status.perror("MFnDagNode::parentCount");
continue;
}
for(unsigned int j = 0; j < parentCount; ++j) {
MObject parent = dagNode.parent(j, &status);
if (!status) {
status.perror("MFnDagNode::parent");
break;
}
MFnDagNode parent_dagNode(parent);
if (parent_dagNode.typeId(&status) == HelixBase::id) {
if (!(status = result.append(parent))) {
status.perror("MObjectArray::append");
return status;
}
}
}
}
}
return MStatus::kSuccess;
}
MStatus slopeShaderBehavior::connectNodeToNode( MObject &sourceNode, MObject &destinationNode, bool force )
//
// Description:
// Overloaded function from MPxDragAndDropBehavior
// this method will handle the connection between the slopeShader and the shader it is
// assigned to as well as any meshes that it is assigned to.
//
{
MStatus result = MS::kFailure;
MFnDependencyNode src(sourceNode);
//if we are dragging from a lambert
//we want to check what we are dragging
//onto.
if(sourceNode.hasFn(MFn::kLambert))
{
MObject shaderNode;
MPlugArray connections;
MObjectArray shaderNodes;
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);
unsigned i;
for(i = 0; i < connections.length(); i++)
{
//check the incoming connections to this plug
//
MPlugArray connectedPlugs;
connections[i].connectedTo(connectedPlugs, true, false);
for(unsigned 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[j].node();
if(MFnDependencyNode(currentnode).typeName() == "slopeShader")
{
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(destinationNode);
if(destinationNode.hasFn(MFn::kMesh))
{
//if the node is a mesh than for each slopeShader
//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 = MFnDependencyNode(shaderNodes[i]).findPlug("dirtyShaderPlug");
if(!srcPlug.isNull() && !destPlug.isNull())
{
MString cmd = "connectAttr -na ";
cmd += srcPlug.name() + " ";
cmd += destPlug.name();
MGlobal::executeCommand(cmd);
}
}
//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())
{
MString cmd = "sets -edit -forceElement ";
cmd += MFnDependencyNode(shadingEngine).name() + " ";
cmd += MFnDagNode(destinationNode).partialPathName();
result = MGlobal::executeCommand(cmd);
}
}
}
}
else if(src.typeName() == "slopeShader")
//if we are dragging from a slope shader
//than we want to see what we are dragging onto
//
{
if(destinationNode.hasFn(MFn::kMesh))
{
//if the user is dragging onto a mesh
//than make the connection from the worldMesh
//to the dirtyShader plug on the slopeShader
//
MFnDependencyNode dest(destinationNode);
MPlug srcPlug = dest.findPlug("worldMesh");
MPlug destPlug = src.findPlug("dirtyShaderPlug");
if(!srcPlug.isNull() && !destPlug.isNull())
{
MString cmd = "connectAttr -na ";
cmd += srcPlug.name() + " ";
cmd += destPlug.name();
result = MGlobal::executeCommand(cmd);
}
}
}
return result;
}
bool getObjectShadingGroups(const MDagPath& shapeObjectDP, MIntArray& perFaceAssignments, MObjectArray& shadingGroups, bool needsPerFaceInfo=true)
{
// if obj is a light, simply return the mobject
if (shapeObjectDP.node().hasFn(MFn::kLight))
{
perFaceAssignments.clear();
shadingGroups.clear();
shadingGroups.append(shapeObjectDP.node());
return true;
}
if (shapeObjectDP.node().hasFn(MFn::kMesh))
{
// Find the Shading Engines Connected to the SourceNode
MFnMesh meshFn(shapeObjectDP.node());
perFaceAssignments.clear();
shadingGroups.clear();
MObjectArray comps;
// this one seems to be extremly much faster if we need no per face informations.
// e.g. for a sphere with 90000 faces, the non per face method needs 0.05 sec. whereas the
// method with per face info needs about 20 sec.
if (!needsPerFaceInfo)
{
meshFn.getConnectedSetsAndMembers(shapeObjectDP.instanceNumber(), shadingGroups, comps, true);
return true;
}
meshFn.getConnectedShaders(shapeObjectDP.instanceNumber(), shadingGroups, perFaceAssignments);
if (!meshFn.findPlug("displaySmoothMesh").asBool())
return true;
MIntArray indices;
indices = perFaceAssignments;
int subdivs = 0;
int multiplier = 0;
if (meshFn.findPlug("displaySmoothMesh").asBool())
{
MMeshSmoothOptions options;
MStatus status = meshFn.getSmoothMeshDisplayOptions(options);
if (status)
{
if (!meshFn.findPlug("useSmoothPreviewForRender", false, &status).asBool())
{
int smoothLevel = meshFn.findPlug("renderSmoothLevel", false, &status).asInt();
options.setDivisions(smoothLevel);
}
subdivs = options.divisions();
if (subdivs > 0)
multiplier = static_cast<int> (pow(4.0f, (subdivs - 1)));
}
}
if (multiplier > 0)
perFaceAssignments.clear();
for (unsigned int i = 0; i < indices.length(); i++)
{
int subdivisions = multiplier * meshFn.polygonVertexCount(i);
int index = 0 > indices[i] ? 0 : indices[i]; // non assigned has -1, but we want 0
perFaceAssignments.append(index);
// simply replicate the index for all subdiv faces
for (int k = 0; k < subdivisions - 1; k++)
perFaceAssignments.append(index);
}
return true;
}
if (shapeObjectDP.node().hasFn(MFn::kNurbsSurface)||shapeObjectDP.hasFn(MFn::kParticle)||shapeObjectDP.hasFn(MFn::kNParticle))
{
MObject instObjGroupsAttr;
if (shapeObjectDP.hasFn(MFn::kNurbsSurface))
{
MFnNurbsSurface fnNurbs(shapeObjectDP.node());
instObjGroupsAttr = fnNurbs.attribute("instObjGroups");
}
if (shapeObjectDP.hasFn(MFn::kParticle)||shapeObjectDP.hasFn(MFn::kNParticle))
{
MFnParticleSystem fnPart(shapeObjectDP.node());
instObjGroupsAttr = fnPart.attribute("instObjGroups");
}
MPlug instPlug(shapeObjectDP.node(), instObjGroupsAttr);
// Get the instance that our node is referring to;
// In other words get the Plug for instObjGroups[intanceNumber];
MPlug instPlugElem = instPlug.elementByLogicalIndex(shapeObjectDP.instanceNumber());
// Find the ShadingGroup plugs that we are connected to as Source
MPlugArray SGPlugArray;
instPlugElem.connectedTo(SGPlugArray, false, true);
perFaceAssignments.clear();
shadingGroups.clear();
// Loop through each ShadingGroup Plug
for (unsigned int i=0; i < SGPlugArray.length(); ++i)
{
shadingGroups.append(SGPlugArray[i].node());
return true;
}
}
return false;
}
