void geometryReplicatorGeometryOverride::updateDG()
{
if (!fPath.isValid()) {
MFnDependencyNode fnThisNode(fThisNode);
MObject messageAttr = fnThisNode.attribute("message");
MPlug messagePlug(fThisNode, messageAttr);
MPlugArray connections;
if (messagePlug.connectedTo(connections, false, true)) {
for (unsigned int i = 0; i < connections.length(); ++i) {
MObject node = connections[i].node();
if (node.hasFn(MFn::kMesh) ||
node.hasFn(MFn::kNurbsSurface) ||
node.hasFn(MFn::kNurbsCurve) ||
node.hasFn(MFn::kBezierCurve))
{
MDagPath path;
MDagPath::getAPathTo(node, path);
fPath = path;
fType = path.apiType();
break;
}
}
}
}
}
MStatus sgCurveEditBrush_context::getShapeNode( MDagPath& path )
{
MStatus status;
if ( path.apiType() == MFn::kNurbsCurve )
{
return MS::kSuccess;
}
unsigned int numShapes;
status = path.numberOfShapesDirectlyBelow( numShapes );
CHECK_MSTATUS_AND_RETURN_IT( status );
for ( unsigned int i = 0; i < numShapes; ++i )
{
status = path.extendToShapeDirectlyBelow( i );
CHECK_MSTATUS_AND_RETURN_IT( status );
if ( !path.hasFn( MFn::kNurbsCurve ) )
{
path.pop();
continue;
}
MFnDagNode fnNode( path, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
if ( !fnNode.isIntermediateObject() )
{
return MS::kSuccess;
}
path.pop();
}
return MS::kFailure;
}
//---------------------------------------------
void IV_makeSelection(void* data)
//---------------------------------------------
{
BPT_InsertVtx* nodePtr = (BPT_InsertVtx*) data;
MEventMessage::removeCallback(nodePtr->eID);
MDagPath meshPath;
nodePtr->getMeshPath(meshPath);
if( !(meshPath.apiType() == MFn::kInvalid) && nodePtr->validIndices.length() != 0) //zur Sicherheit, sollte aber eigentlich nicht mueueglich sein
{
MFnSingleIndexedComponent compFn;
MFn::Type type = MFn::kInvalid;
if(nodePtr->validIndices[0] == 1)
type = MFn::kMeshEdgeComponent;
else if(nodePtr->validIndices[0] == 2)
type = MFn::kMeshPolygonComponent;
else if(nodePtr->validIndices[0] == 3)
type = MFn::kMeshVertComponent;
assert(type != MFn::kInvalid);
//flag wieder entfernen
nodePtr->validIndices.remove(0);
MSelectionList compList, current;
MObject comps = compFn.create(type);
compFn.addElements(nodePtr->validIndices);
compList.add(meshPath,comps);
compList.add(nodePtr->thisMObject());
// MGlobal::getActiveSelectionList(current);
MGlobal::setActiveSelectionList(compList, MGlobal::kAddToList);
// MGlobal::setActiveSelectionList(current,MGlobal::kAddToList);
}
}
bool GDExporter::GetSelectedMeshTransformPath(MDagPath &transformPath)
{
MSelectionList currSelection;
MGlobal::getActiveSelectionList(currSelection);
unsigned int selectionCount = currSelection.length();
MFnMesh* exportingMesh = 0;
for(unsigned int selectionIndex = 0; selectionIndex < selectionCount; ++selectionIndex )
{
MDagPath currPath;
currSelection.getDagPath(selectionIndex, currPath);
if( currPath.apiType() != MFn::kTransform )
continue;
MFnTransform currTransform(currPath);
unsigned int childCount = currTransform.childCount();
for(unsigned int childIndex = 0; childIndex < childCount; ++childIndex)
{
MObject childObject = currTransform.child(childIndex);
if( childObject.apiType() == MFn::kMesh )
{
MFnMesh childMesh(childObject);
if( childMesh.isIntermediateObject() )
continue;
currTransform.getPath(transformPath);
return true;
}
}
}
return false;
}
bool CXRayObjectExport::initializeSetsAndLookupTables( bool exportAll )
//
// Description :
// Creates a list of all sets in Maya, a list of mesh objects,
// and polygon/vertex lookup tables that will be used to
// determine which sets are referenced by the poly components.
//
{
int i=0,j=0, length;
MStatus stat;
// Initialize class data.
// Note: we cannot do this in the constructor as it
// only gets called upon registry of the plug-in.
//
numSets = 0;
sets = NULL;
lastSets = NULL;
lastMaterials = NULL;
objectId = 0;
objectCount = 0;
polygonTable = NULL;
vertexTable = NULL;
polygonTablePtr = NULL;
vertexTablePtr = NULL;
objectGroupsTablePtr = NULL;
objectNodeNamesArray.clear();
transformNodeNameArray.clear();
//////////////////////////////////////////////////////////////////
//
// Find all sets in Maya and store the ones we care about in
// the 'sets' array. Also make note of the number of sets.
//
//////////////////////////////////////////////////////////////////
// Get all of the sets in maya and put them into
// a selection list
//
MStringArray result;
MGlobal::executeCommand( "ls -sets", result );
MSelectionList * setList = new MSelectionList();
length = result.length();
for ( i=0; i<length; i++ )
{
setList->add( result[i] );
}
// Extract each set as an MObject and add them to the
// sets array.
// We may be excluding groups, matierials, or ptGroups
// in which case we can ignore those sets.
//
MObject mset;
sets = new MObjectArray();
length = setList->length();
for ( i=0; i<length; i++ )
{
setList->getDependNode( i, mset );
MFnSet fnSet( mset, &stat );
if ( stat ) {
if ( MFnSet::kRenderableOnly == fnSet.restriction(&stat) ) {
sets->append( mset );
}
}
}
xr_delete(setList);
numSets = sets->length();
//////////////////////////////////////////////////////////////////
//
// Do a dag-iteration and for every mesh found, create facet and
// vertex look-up tables. These tables will keep track of which
// sets each component belongs to.
//
// If exportAll is false then iterate over the activeSelection
// list instead of the entire DAG.
//
// These arrays have a corrisponding entry in the name
// stringArray.
//
//////////////////////////////////////////////////////////////////
MIntArray vertexCounts;
MIntArray polygonCounts;
if ( exportAll ) {
MItDag dagIterator( MItDag::kBreadthFirst, MFn::kInvalid, &stat);
if ( MS::kSuccess != stat) {
fprintf(stderr,"Failure in DAG iterator setup.\n");
return false;
}
objectNames = new MStringArray();
for ( ; !dagIterator.isDone(); dagIterator.next() )
{
MDagPath dagPath;
stat = dagIterator.getPath( dagPath );
if ( stat )
{
// skip over intermediate objects
//
MFnDagNode dagNode( dagPath, &stat );
if (dagNode.isIntermediateObject())
{
continue;
}
if (( dagPath.hasFn(MFn::kMesh)) &&
( dagPath.hasFn(MFn::kTransform)))
{
// We want only the shape,
// not the transform-extended-to-shape.
continue;
}
else if ( dagPath.hasFn(MFn::kMesh))
{
// We have a mesh so create a vertex and polygon table
// for this object.
//
MFnMesh fnMesh( dagPath );
int vtxCount = fnMesh.numVertices();
int polygonCount = fnMesh.numPolygons();
// we do not need this call anymore, we have the shape.
// dagPath.extendToShape();
MString name = dagPath.fullPathName();
objectNames->append( name );
objectNodeNamesArray.append( fnMesh.name() );
vertexCounts.append( vtxCount );
polygonCounts.append( polygonCount );
objectCount++;
}
}
}
}else{
MSelectionList slist;
MGlobal::getActiveSelectionList( slist );
MItSelectionList iter( slist );
MStatus status;
objectNames = new MStringArray();
// We will need to interate over a selected node's heirarchy
// in the case where shapes are grouped, and the group is selected.
MItDag dagIterator( MItDag::kDepthFirst, MFn::kInvalid, &status);
for ( ; !iter.isDone(); iter.next() ){
MDagPath objectPath;
stat = iter.getDagPath( objectPath );
// reset iterator's root node to be the selected node.
status = dagIterator.reset (objectPath.node(),
MItDag::kDepthFirst, MFn::kInvalid );
// DAG iteration beginning at at selected node
for ( ; !dagIterator.isDone(); dagIterator.next() ){
MDagPath dagPath;
MObject component = MObject::kNullObj;
status = dagIterator.getPath(dagPath);
if (!status){
fprintf(stderr,"Failure getting DAG path.\n");
freeLookupTables();
return false;
}
// skip over intermediate objects
//
MFnDagNode dagNode( dagPath, &stat );
if (dagNode.isIntermediateObject()) continue;
if (( dagPath.hasFn(MFn::kMesh)) && ( dagPath.hasFn(MFn::kTransform))){
// We want only the shape,
// not the transform-extended-to-shape.
continue;
}else if ( dagPath.hasFn(MFn::kMesh)){
// We have a mesh so create a vertex and polygon table
// for this object.
//
MFnMesh fnMesh( dagPath );
int vtxCount = fnMesh.numVertices();
int polygonCount = fnMesh.numPolygons();
// we do not need this call anymore, we have the shape.
// dagPath.extendToShape();
MString name = dagPath.fullPathName();
objectNames->append( name );
objectNodeNamesArray.append( fnMesh.name() );
vertexCounts.append( vtxCount );
polygonCounts.append( polygonCount );
objectCount++;
}
}
}
}
// Now we know how many objects we are dealing with
// and we have counts of the vertices/polygons for each
// object so create the maya group look-up table.
//
if( objectCount > 0 ) {
// To export Maya groups we traverse the hierarchy starting at
// each objectNodeNamesArray[i] going towards the root collecting transform
// nodes as we go.
length = objectNodeNamesArray.length();
for( i=0; i<length; i++ ) {
MIntArray transformNodeNameIndicesArray;
recFindTransformDAGNodes( objectNodeNamesArray[i], transformNodeNameIndicesArray );
}
if( transformNodeNameArray.length() > 0 ) {
objectGroupsTablePtr = xr_alloc<bool*>(objectCount);// (bool**) malloc( sizeof(bool*)*objectCount );
length = transformNodeNameArray.length();
for ( i=0; i<objectCount; i++ )
{
// objectGroupsTablePtr[i] = (bool*)calloc( length, sizeof(bool) );
objectGroupsTablePtr[i] = xr_alloc<bool>(length);
ZeroMemory(objectGroupsTablePtr[i],length*sizeof(bool));
// XXX nitrocaster: remove this 'cause malloc failure shouldn't be handled there
if ( objectGroupsTablePtr[i] == NULL ) {
Log("! calloc returned NULL (objectGroupsTablePtr)");
return false;
}
}
}
// else{
// Log("! Can't find transform for node.");
// return false;
// }
}
// Create the vertex/polygon look-up tables.
//
if ( objectCount > 0 ) {
vertexTablePtr = xr_alloc<bool*>(objectCount); //(bool**) malloc( sizeof(bool*)*objectCount );
polygonTablePtr = xr_alloc<bool*>(objectCount); //(bool**) malloc( sizeof(bool*)*objectCount );
for ( i=0; i<objectCount; i++ )
{
// vertexTablePtr[i] = (bool*)calloc( vertexCounts[i]*numSets, sizeof(bool) );
vertexTablePtr[i] = xr_alloc<bool>(vertexCounts[i]*numSets);
ZeroMemory(vertexTablePtr[i],vertexCounts[i]*numSets*sizeof(bool));
// XXX nitrocaster: remove this 'cause malloc failure shouldn't be handled there
if ( vertexTablePtr[i] == NULL ) {
Log("! calloc returned NULL (vertexTable)");
return false;
}
// polygonTablePtr[i] = (bool*)calloc( polygonCounts[i]*numSets, sizeof(bool) );
polygonTablePtr[i] = xr_alloc<bool>(polygonCounts[i]*numSets);
ZeroMemory(polygonTablePtr[i],polygonCounts[i]*numSets*sizeof(bool));
// XXX nitrocaster: remove this 'cause malloc failure shouldn't be handled there
if ( polygonTablePtr[i] == NULL ) {
Log("! calloc returned NULL (polygonTable)");
return false;
}
}
}
// If we found no meshes then return
//
if ( objectCount == 0 ) {
return false;
}
//////////////////////////////////////////////////////////////////
//
// Go through all of the set members (flattened lists) and mark
// in the lookup-tables, the sets that each mesh component belongs
// to.
//
//
//////////////////////////////////////////////////////////////////
bool flattenedList = true;
MDagPath object;
MObject component;
MSelectionList memberList;
for ( i=0; i<numSets; i++ )
{
MFnSet fnSet( (*sets)[i] );
memberList.clear();
stat = fnSet.getMembers( memberList, flattenedList );
if (MS::kSuccess != stat) {
fprintf(stderr,"Error in fnSet.getMembers()!\n");
}
int m, numMembers;
numMembers = memberList.length();
for ( m=0; m<numMembers; m++ )
{
if ( memberList.getDagPath(m,object,component) ) {
if ( (!component.isNull()) && (object.apiType() == MFn::kMesh) )
{
if (component.apiType() == MFn::kMeshVertComponent) {
MItMeshVertex viter( object, component );
for ( ; !viter.isDone(); viter.next() )
{
int compIdx = viter.index();
MString name = object.fullPathName();
// Figure out which object vertexTable
// to get.
//
int o, numObjectNames;
numObjectNames = objectNames->length();
for ( o=0; o<numObjectNames; o++ ) {
if ( (*objectNames)[o] == name ) {
// Mark set i as true in the table
//
vertexTable = vertexTablePtr[o];
*(vertexTable + numSets*compIdx + i) = true;
break;
}
}
}
}
else if (component.apiType() == MFn::kMeshPolygonComponent)
{
MItMeshPolygon piter( object, component );
for ( ; !piter.isDone(); piter.next() )
{
int compIdx = piter.index();
MString name = object.fullPathName();
// Figure out which object polygonTable
// to get.
//
int o, numObjectNames;
numObjectNames = objectNames->length();
for ( o=0; o<numObjectNames; o++ ) {
if ( (*objectNames)[o] == name ) {
// Mark set i as true in the table
//
// Check for bad components in the set
//
if ( compIdx >= polygonCounts[o] ) {
Msg("! Bad polygon index '%d' found. Polygon skipped",compIdx);
break;
}
polygonTable = polygonTablePtr[o];
*(polygonTable + numSets*compIdx + i) = true;
break;
}
}
}
}
}
else {
// There are no components, therefore we can mark
// all polygons as members of the given set.
//
if (object.hasFn(MFn::kMesh)) {
MFnMesh fnMesh( object, &stat );
if ( MS::kSuccess != stat) {
fprintf(stderr,"Failure in MFnMesh initialization.\n");
return false;
}
// We are going to iterate over all the polygons.
//
MItMeshPolygon piter( object, MObject::kNullObj, &stat );
if ( MS::kSuccess != stat) {
fprintf(stderr,
"Failure in MItMeshPolygon initialization.\n");
return false;
}
for ( ; !piter.isDone(); piter.next() )
{
int compIdx = piter.index();
MString name = object.fullPathName();
// Figure out which object polygonTable to get.
//
int o, numObjectNames;
numObjectNames = objectNames->length();
for ( o=0; o<numObjectNames; o++ ) {
if ( (*objectNames)[o] == name ) {
// Check for bad components in the set
//
if ( compIdx >= polygonCounts[o] ) {
Msg("! Bad polygon index '%d' found. Polygon skipped",compIdx);
break;
}
// Mark set i as true in the table
//
polygonTable = polygonTablePtr[o];
*(polygonTable + numSets*compIdx + i) = true;
break;
}
}
} // end of piter.next() loop
} // end of condition if (object.hasFn(MFn::kMesh))
} // end of else condifion if (!component.isNull())
} // end of memberList.getDagPath(m,object,component)
} // end of memberList loop
} // end of for-loop for sets
// Go through all of the group members and mark in the
// lookup-table, the group that each shape belongs to.
length = objectNodeNamesArray.length();
if (objectGroupsTablePtr){
for( i=0; i<length; i++ ) {
MIntArray groupTableIndicesArray;
bool *objectGroupTable = objectGroupsTablePtr[i];
int length2;
recFindTransformDAGNodes( objectNodeNamesArray[i], groupTableIndicesArray );
length2 = groupTableIndicesArray.length();
for( j=0; j<length2; j++ ) {
int groupIdx = groupTableIndicesArray[j];
objectGroupTable[groupIdx] = true;
}
}
}
return true;
}
void DMPDSExporter::fillSubSkeleton( DMPParameters* param, const MDagPath& subSkelDag )
{
if (subSkelDag.apiType() != MFn::kJoint)
{
return; // early out.
}
MStatus status;
// try to retrieve the root path, otherwise ignore it.
MDagPath rootJntDag, tmpJointPath;
tmpJointPath = subSkelDag;
rootJntDag = tmpJointPath;
while (tmpJointPath.length() > 0)
{
tmpJointPath.pop();
if (tmpJointPath.hasFn(MFn::kJoint) && (tmpJointPath.length() > 0))
{
rootJntDag = tmpJointPath;
}
}
// check whether we have processed this joint.
for (unsigned int i = 0; i < mSkelData.skeleton.subSkeletons.size(); ++i)
{
if (mSkelData.skeleton.subSkeletons[i].name == rootJntDag.partialPathName().asUTF8())
{
return;
}
}
DMPSkeletonData::SubSkeletonStruct newSkel;
newSkel.name = rootJntDag.partialPathName().asUTF8();
//set the skeleton to the desired neutral pose
if (param->neutralPoseType == DMPParameters::NPT_SkinBindPose)
{
MGlobal::executeCommand("select " + rootJntDag.fullPathName(),true);
//disable constraints, IK, etc...
MGlobal::executeCommand("doEnableNodeItems false all",true);
// Note: we reset to the bind pose
MGlobal::executeCommand("dagPose -r -g -bp",true);
}
// build animation clip info, for animation exporting.
if (param->bExportSkelAnimation)
{
for (unsigned int i = 0; i < param->clipList.size(); ++i)
{
// convert to realtime speed(seconds);
float sampleRate;
float clipStart;
float clipEnd;
if (param->animSampleType == DMPParameters::AST_Frame)
{
sampleRate = param->samplerRate / param->fps;
clipStart = (param->clipList[i].start - 1.0f) / param->fps; // include the first clip;
clipEnd = param->clipList[i].end / param->fps;
}
else
{
sampleRate = param->samplerRate;
clipStart = param->clipList[i].start;
clipEnd = param->clipList[i].end;
}
DMPSkeletonData::TransformAnimation newAnim;
newAnim.name = param->clipList[i].clipName.asUTF8();
newAnim.startTime = clipStart;
newAnim.endTime = clipEnd;
newSkel.animations.push_back(newAnim);
}
}
fillBones(&newSkel, "", param, rootJntDag);
mSkelData.skeleton.subSkeletons.push_back(newSkel);
}
void DMPDSExporter::fillBones( DMPSkeletonData::SubSkeletonStruct* subSkel, string parent, DMPParameters* param, MDagPath& jointDag )
{
MStatus status;
if (jointDag.apiType() != MFn::kJoint)
{
return; // early out.
}
DMPSkeletonData::BoneStruct newBone;
newBone.boneHandle = (unsigned int)subSkel->bones.size();
newBone.name = jointDag.partialPathName().asUTF8();
newBone.parentName = parent;
MFnIkJoint fnJoint(jointDag, &status);
// matrix = [S] * [RO] * [R] * [JO] * [IS] * [T]
/*
These matrices are defined as follows:
•[S] : scale
•[RO] : rotateOrient (attribute name is rotateAxis)
•[R] : rotate
•[JO] : jointOrient
•[IS] : parentScaleInverse
•[T] : translate
The methods to get the value of these matrices are:
•[S] : getScale
•[RO] : getScaleOrientation
•[R] : getRotation
•[JO] : getOrientation
•[IS] : (the inverse of the getScale on the parent transformation matrix)
•[T] : translation
*/
MVector trans = fnJoint.getTranslation(MSpace::kTransform);
double scale[3];
fnJoint.getScale(scale);
MQuaternion R, RO, JO;
fnJoint.getScaleOrientation(RO);
fnJoint.getRotation(R);
fnJoint.getOrientation(JO);
MQuaternion rot = RO * R * JO;
newBone.translate[0] = trans.x * param->lum;
newBone.translate[1] = trans.y * param->lum;
newBone.translate[2] = trans.z * param->lum;
newBone.orientation[0] = rot.w;
newBone.orientation[1] = rot.x;
newBone.orientation[2] = rot.y;
newBone.orientation[3] = rot.z;
newBone.scale[0] = scale[0];
newBone.scale[1] = scale[1];
newBone.scale[2] = scale[2];
subSkel->bones.push_back(newBone);
// Load child joints
for (unsigned int i=0; i<jointDag.childCount();i++)
{
MObject child;
child = jointDag.child(i);
MDagPath childDag = jointDag;
childDag.push(child);
fillBones(subSkel, newBone.name, param, childDag);
}
// now go for animations
if (param->bExportSkelAnimation)
{
for (unsigned int i = 0; i < subSkel->animations.size(); ++i)
{
DMPSkeletonData::TransformAnimation& anim = subSkel->animations[i];
DMPSkeletonData::TransformTrack subTrack;
subTrack.targetBone = newBone.name;
MPlug plugT; // translate
MPlug plugR; // R
MPlug plugRO; // RO
MPlug plugJO; // JO
MPlug plugS; // scale
double dataT[3];
double dataR[3];
double dataRO[3];
double dataJO[3];
double dataS[3];
MFnDependencyNode fnDependNode( jointDag.node(), &status );
plugT = fnDependNode.findPlug("translate", false, &status);
plugR = fnDependNode.findPlug("rotate", false, &status);
plugRO = fnDependNode.findPlug("rotateAxis", false, &status);
plugJO = fnDependNode.findPlug("jointOrient", false, &status);
plugS = fnDependNode.findPlug("scale", false, &status);
float timeStep = param->samplerRate;
if (param->animSampleType == DMPParameters::AST_Frame)
{
timeStep /= param->fps;
}
for (float curTime = anim.startTime; curTime <= anim.endTime; curTime += timeStep)
{
MTime mayaTime;
DMPSkeletonData::TransformKeyFrame keyframe;
keyframe.time = curTime - anim.startTime;
mayaTime.setUnit(MTime::kSeconds);
mayaTime.setValue(curTime);
// Get its value at the specified Time.
plugT.child(0).getValue(dataT[0], MDGContext(mayaTime));
plugT.child(1).getValue(dataT[1], MDGContext(mayaTime));
plugT.child(2).getValue(dataT[2], MDGContext(mayaTime));
plugR.child(0).getValue(dataR[0], MDGContext(mayaTime));
plugR.child(1).getValue(dataR[1], MDGContext(mayaTime));
plugR.child(2).getValue(dataR[2], MDGContext(mayaTime));
plugRO.child(0).getValue(dataRO[0], MDGContext(mayaTime));
plugRO.child(1).getValue(dataRO[1], MDGContext(mayaTime));
plugRO.child(2).getValue(dataRO[2], MDGContext(mayaTime));
plugJO.child(0).getValue(dataJO[0], MDGContext(mayaTime));
plugJO.child(1).getValue(dataJO[1], MDGContext(mayaTime));
plugJO.child(2).getValue(dataJO[2], MDGContext(mayaTime));
plugS.child(0).getValue(dataS[0], MDGContext(mayaTime));
plugS.child(1).getValue(dataS[1], MDGContext(mayaTime));
plugS.child(2).getValue(dataS[2], MDGContext(mayaTime));
// fill the frame.
keyframe.translate[0] = dataT[0] * param->lum;
keyframe.translate[1] = dataT[1] * param->lum;
keyframe.translate[2] = dataT[2] * param->lum;
// calculate quaternion.
MEulerRotation rotR(dataR[0], dataR[1], dataR[2]);
MEulerRotation rotRO(dataRO[0], dataRO[1], dataRO[2]);
MEulerRotation rotJO(dataJO[0], dataJO[1], dataJO[2]);
MQuaternion finalRot = rotRO.asQuaternion()*rotR.asQuaternion()*rotJO.asQuaternion();
keyframe.orientation[0] = finalRot.w;
keyframe.orientation[1] = finalRot.x;
keyframe.orientation[2] = finalRot.y;
keyframe.orientation[3] = finalRot.z;
keyframe.scale[0] = dataS[0];
keyframe.scale[1] = dataS[1];
keyframe.scale[2] = dataS[2];
subTrack.frames.push_back(keyframe);
}
anim.tracks.push_back(subTrack);
}
}
}
MFnMesh* GDExporter::GetSelectedMesh(void)
{
MSelectionList currSelection;
MGlobal::getActiveSelectionList(currSelection);
unsigned int selectionCount = currSelection.length();
MFnMesh* exportingMesh = 0;
for(unsigned int selectionIndex = 0; selectionIndex < selectionCount; ++selectionIndex )
{
MDagPath currPath;
currSelection.getDagPath(selectionIndex, currPath);
if( currPath.apiType() != MFn::kTransform )
continue;
MFnTransform currTransform(currPath);
unsigned int childCount = currTransform.childCount();
for(unsigned int childIndex = 0; childIndex < childCount; ++childIndex)
{
MObject childObject = currTransform.child(childIndex);
if( childObject.apiType() == MFn::kMesh )
{
MFnDagNode dagNode;
dagNode.setObject(childObject);
MDagPath childPath;
dagNode.getPath(childPath);
MFnMesh* pChildMesh = new MFnMesh(childPath);
if( pChildMesh->isIntermediateObject() )
continue;
bool bExportMesh = true;
if( pChildMesh->isInstanced(false) )
if( childPath.instanceNumber() != 0 )
bExportMesh = false;
if( bExportMesh )
{
if( exportingMesh != 0 )
{
delete exportingMesh;
delete pChildMesh;
MGlobal::displayError(MString("GDExporter - More than one mesh object selected."));
return 0;
}
exportingMesh = pChildMesh;
}
}
}
}
if( exportingMesh == 0 )
{
MGlobal::displayError(MString("GDExporter - No mesh objects currently selected."));
return 0;
}
return exportingMesh;
}
// Method for iterating over nodes in a dependency graph from top to bottom
MStatus OgreExporter::translateNode(MDagPath& dagPath)
{
if (m_params.exportAnimCurves)
{
MObject dagPathNode = dagPath.node();
MItDependencyGraph animIter( dagPathNode,
MFn::kAnimCurve,
MItDependencyGraph::kUpstream,
MItDependencyGraph::kDepthFirst,
MItDependencyGraph::kNodeLevel,
&stat );
if (stat)
{
for (; !animIter.isDone(); animIter.next())
{
MObject anim = animIter.thisNode(&stat);
MFnAnimCurve animFn(anim,&stat);
std::cout << "Found animation curve: " << animFn.name().asChar() << "\n";
std::cout << "Translating animation curve: " << animFn.name().asChar() << "...\n";
std::cout.flush();
stat = writeAnim(animFn);
if (MS::kSuccess == stat)
{
std::cout << "OK\n";
std::cout.flush();
}
else
{
std::cout << "Error, Aborting operation\n";
std::cout.flush();
return MS::kFailure;
}
}
}
}
if (dagPath.hasFn(MFn::kMesh)&&(m_params.exportMesh||m_params.exportMaterial||m_params.exportSkeleton)
&& (dagPath.childCount() == 0))
{ // we have found a mesh shape node, it can't have any children, and it contains
// all the mesh geometry data
MDagPath meshDag = dagPath;
MFnMesh meshFn(meshDag);
if (!meshFn.isIntermediateObject())
{
std::cout << "Found mesh node: " << meshDag.fullPathName().asChar() << "\n";
std::cout << "Loading mesh node " << meshDag.fullPathName().asChar() << "...\n";
std::cout.flush();
stat = m_pMesh->load(meshDag,m_params);
if (MS::kSuccess == stat)
{
std::cout << "OK\n";
std::cout.flush();
}
else
{
std::cout << "Error, mesh skipped\n";
std::cout.flush();
}
}
}
else if (dagPath.hasFn(MFn::kCamera)&&(m_params.exportCameras) && (!dagPath.hasFn(MFn::kShape)))
{ // we have found a camera shape node, it can't have any children, and it contains
// all information about the camera
MFnCamera cameraFn(dagPath);
if (!cameraFn.isIntermediateObject())
{
std::cout << "Found camera node: "<< dagPath.fullPathName().asChar() << "\n";
std::cout << "Translating camera node: "<< dagPath.fullPathName().asChar() << "...\n";
std::cout.flush();
stat = writeCamera(cameraFn);
if (MS::kSuccess == stat)
{
std::cout << "OK\n";
std::cout.flush();
}
else
{
std::cout << "Error, Aborting operation\n";
std::cout.flush();
return MS::kFailure;
}
}
}
else if ( ( dagPath.apiType() == MFn::kParticle ) && m_params.exportParticles )
{ // we have found a set of particles
MFnDagNode fnNode(dagPath);
if (!fnNode.isIntermediateObject())
{
std::cout << "Found particles node: "<< dagPath.fullPathName().asChar() << "\n";
std::cout << "Translating particles node: "<< dagPath.fullPathName().asChar() << "...\n";
std::cout.flush();
Particles particles;
particles.load(dagPath,m_params);
stat = particles.writeToXML(m_params);
if (MS::kSuccess == stat)
{
std::cout << "OK\n";
std::cout.flush();
}
else
{
std::cout << "Error, Aborting operation\n";
std::cout.flush();
return MS::kFailure;
}
}
}
// look for meshes and cameras within the node's children
for (uint i=0; i<dagPath.childCount(); i++)
{
MObject child = dagPath.child(i);
MDagPath childPath = dagPath;
stat = childPath.push(child);
if (MS::kSuccess != stat)
{
std::cout << "Error retrieving path to child " << i << " of: " << dagPath.fullPathName().asChar();
std::cout.flush();
return MS::kFailure;
}
stat = translateNode(childPath);
if (MS::kSuccess != stat)
return MS::kFailure;
}
return MS::kSuccess;
}
void liqWriteArchive::writeObjectToRib(const MDagPath &objDagPath, bool writeTransform)
{
if (!isObjectVisible(objDagPath)) {
return;
}
if (debug) { cout << "liquidWriteArchive: writing object: " << objDagPath.fullPathName().asChar() << endl; }
if (objDagPath.node().hasFn(MFn::kShape) || MFnDagNode( objDagPath ).typeName() == "liquidCoorSys") {
// we're looking at a shape node, so write out the geometry to the RIB
outputObjectName(objDagPath);
liqRibNode ribNode;
ribNode.set(objDagPath, 0, MRT_Unknown);
// don't write out clipping planes
if ( ribNode.object(0)->type == MRT_ClipPlane ) return;
if ( ribNode.rib.box != "" && ribNode.rib.box != "-" ) {
RiArchiveRecord( RI_COMMENT, "Additional RIB:\n%s", ribNode.rib.box.asChar() );
}
if ( ribNode.rib.readArchive != "" && ribNode.rib.readArchive != "-" ) {
// the following test prevents a really nasty infinite loop !!
if ( ribNode.rib.readArchive != outputFilename )
RiArchiveRecord( RI_COMMENT, "Read Archive Data: \nReadArchive \"%s\"", ribNode.rib.readArchive.asChar() );
}
if ( ribNode.rib.delayedReadArchive != "" && ribNode.rib.delayedReadArchive != "-" ) {
// the following test prevents a really nasty infinite loop !!
if ( ribNode.rib.delayedReadArchive != outputFilename )
RiArchiveRecord( RI_COMMENT, "Delayed Read Archive Data: \nProcedural \"DelayedReadArchive\" [ \"%s\" ] [ %f %f %f %f %f %f ]", ribNode.rib.delayedReadArchive.asChar(), ribNode.bound[0], ribNode.bound[3], ribNode.bound[1], ribNode.bound[4], ribNode.bound[2], ribNode.bound[5]);
}
// If it's a curve we should write the basis function
if ( ribNode.object(0)->type == MRT_NuCurve ) {
RiBasis( RiBSplineBasis, 1, RiBSplineBasis, 1 );
}
if ( !ribNode.object(0)->ignore ) {
ribNode.object(0)->writeObject();
}
} else {
// we're looking at a transform node
bool wroteTransform = false;
if (writeTransform && (objDagPath.apiType() == MFn::kTransform)) {
if (debug) { cout << "liquidWriteArchive: writing transform: " << objDagPath.fullPathName().asChar() << endl; }
// push the transform onto the RIB stack
outputObjectName(objDagPath);
MFnDagNode mfnDag(objDagPath);
MMatrix tm = mfnDag.transformationMatrix();
if (true) { // (!tm.isEquivalent(MMatrix::identity)) {
RtMatrix riTM;
tm.get(riTM);
wroteTransform = true;
outputIndentation();
RiAttributeBegin();
indentLevel++;
outputIndentation();
RiConcatTransform(riTM);
}
}
// go through all the children of this node and deal with each of them
int nChildren = objDagPath.childCount();
if (debug) { cout << "liquidWriteArchive: object " << objDagPath.fullPathName().asChar() << "has " << nChildren << " children" << endl; }
for(int i=0; i<nChildren; ++i) {
if (debug) { cout << "liquidWriteArchive: writing child number " << i << endl; }
MDagPath childDagNode;
MStatus stat = MDagPath::getAPathTo(objDagPath.child(i), childDagNode);
if (stat) {
writeObjectToRib(childDagNode, outputChildTransforms);
} else {
MGlobal::displayWarning("error getting a dag path to child node of object " + objDagPath.fullPathName());
}
}
if (wroteTransform) {
indentLevel--;
outputIndentation();
RiAttributeEnd();
}
}
if (debug) { cout << "liquidWriteArchive: finished writing object: " << objDagPath.fullPathName().asChar() << endl; }
}