bool util::isAncestorDescendentRelationship(const MDagPath & path1,
const MDagPath & path2)
{
unsigned int length1 = path1.length();
unsigned int length2 = path2.length();
unsigned int diff;
if (length1 == length2 && !(path1 == path2))
return false;
MDagPath ancestor, descendent;
if (length1 > length2)
{
ancestor = path2;
descendent = path1;
diff = length1 - length2;
}
else
{
ancestor = path1;
descendent = path2;
diff = length2 - length1;
}
descendent.pop(diff);
bool ret = (ancestor == descendent);
if (ret)
{
MString err = path1.fullPathName() + " and ";
err += path2.fullPathName() + " have parenting relationships";
MGlobal::displayError(err);
}
return ret;
}
// ------------------------------------------------------------
void SceneGraph::appendForcedNodeToList ( const MDagPath& dagPath )
{
// Attach a function set
MFnDependencyNode fn ( dagPath.node() );
String theNodeName = fn.name().asChar();
MDagPath dagPathCopy = dagPath;
while ( dagPathCopy.length() > 0 && !isForcedNode ( dagPathCopy ) )
{
// Attach a function set
MFnDependencyNode fn ( dagPathCopy.node() );
String theNodeName = fn.name().asChar();
mForcedNodes.append ( dagPathCopy );
dagPathCopy.pop();
}
}
// Remove any DAG object not in the selectedObjects list.
void ShapeMonitor::stopWatchingUnselectedDagObjects(MSelectionList& selectedObjects)
{
// For each monitored object...
for (int i = monitoredObjectsPtrArray.length()-1; i >= 0; i--)
{
MonitoredObject *pMonObject = monitoredObjectsPtrArray[i];
MStatus stat;
// Get an MObject for the MonitoredObject->mayaNodeName.
MDagPath dagpath;
MSelectionList selList;
selList.add(pMonObject->mayaNodeName);
stat = selList.getDagPath(0, dagpath);
// If the MObject is a DAG node...
if (stat)
{
bool found = false;
// Check if the dag path is included in the selectedObjects list.
// For example, say that dagpath = "|group1|group2|pSphere|pSphereShape",
// selectedObjects contains "|group1|group2".
// We first check if dagpath is included in selectedObjects. If that's not the
// case, we pop() one component, so that dagpath = "|group1|group2|pSphere", then
// check again. We do that until either the dagpath is found to be included in
// the selectedObjects list, or until there's no component left in dagpath.
while (!found && dagpath.length() > 0)
{
// Since we store the shape name (as opposed to the parent transform dagpath),
// we need to pop() to get the parent transform dagpath.
dagpath.pop();
MObject component;
// Check if the dag path is included in the objects list.
if (selectedObjects.hasItemPartly(dagpath, component))
found = true;
}
// If the object was not in the selectedObjects list, stop watching it.
if (!found)
stopWatching(pMonObject->mayaNodeName);
}
}
}
// --------------------------------------
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);
}
}
//---------------------------------------------------
// Get a dag path or node from a String
MDagPath DagHelper::getShortestDagPath ( const MObject& node )
{
MDagPathArray paths;
MDagPath::getAllPathsTo ( node, paths );
MDagPath shortestPath;
if ( paths.length() > 0 )
{
shortestPath = paths[0];
for ( uint i = 1; i < paths.length(); ++i )
{
if ( shortestPath.length() > paths[i].length() )
{
shortestPath = paths[i];
}
}
}
return shortestPath;
}
bool usdWriteJob::beginJob(const std::string &iFileName,
bool append,
double startTime,
double endTime)
{
// Check for DAG nodes that are a child of an already specified DAG node to export
// if that's the case, report the issue and skip the export
PxrUsdMayaUtil::ShapeSet::const_iterator m, n;
PxrUsdMayaUtil::ShapeSet::const_iterator endPath = mArgs.dagPaths.end();
for (m = mArgs.dagPaths.begin(); m != endPath; ) {
MDagPath path1 = *m; m++;
for (n = m; n != endPath; n++) {
MDagPath path2 = *n;
if (PxrUsdMayaUtil::isAncestorDescendentRelationship(path1,path2)) {
MString errorMsg = path1.fullPathName();
errorMsg += " and ";
errorMsg += path2.fullPathName();
errorMsg += " have an ancestor relationship. Skipping USD Export.";
MGlobal::displayError(errorMsg);
return false;
}
} // for n
} // for m
// Make sure the file name is a valid one with a proper USD extension.
const std::string iFileExtension = TfStringGetSuffix(iFileName, '.');
if (iFileExtension == PxrUsdMayaTranslatorTokens->UsdFileExtensionDefault ||
iFileExtension == PxrUsdMayaTranslatorTokens->UsdFileExtensionASCII ||
iFileExtension == PxrUsdMayaTranslatorTokens->UsdFileExtensionCrate) {
mFileName = iFileName;
} else {
mFileName = TfStringPrintf("%s.%s",
iFileName.c_str(),
PxrUsdMayaTranslatorTokens->UsdFileExtensionDefault.GetText());
}
MGlobal::displayInfo("usdWriteJob::beginJob: Create stage file "+MString(mFileName.c_str()));
ArResolverContext resolverCtx = ArGetResolver().GetCurrentContext();
if (append) {
mStage = UsdStage::Open(SdfLayer::FindOrOpen(mFileName), resolverCtx);
if (!mStage) {
MGlobal::displayError("Failed to open stage file "+MString(mFileName.c_str()));
return false;
}
} else {
mStage = UsdStage::CreateNew(mFileName, resolverCtx);
if (!mStage) {
MGlobal::displayError("Failed to create stage file "+MString(mFileName.c_str()));
return false;
}
}
// Set time range for the USD file
mStage->SetStartTimeCode(startTime);
mStage->SetEndTimeCode(endTime);
mModelKindWriter.Reset();
// Setup the requested render layer mode:
// defaultLayer - Switch to the default render layer before exporting,
// then switch back afterwards (no layer switching if
// the current layer IS the default layer).
// currentLayer - No layer switching before or after exporting. Just
// use whatever is the current render layer for export.
// modelingVariant - Switch to the default render layer before exporting,
// and export each render layer in the scene as a
// modeling variant, then switch back afterwards (no
// layer switching if the current layer IS the default
// layer). The default layer will be made the default
// modeling variant.
MFnRenderLayer currentLayer(MFnRenderLayer::currentLayer());
mCurrentRenderLayerName = currentLayer.name();
if (mArgs.renderLayerMode == PxUsdExportJobArgsTokens->modelingVariant) {
// Handle usdModelRootOverridePath for USD Variants
MFnRenderLayer::listAllRenderLayers(mRenderLayerObjs);
if (mRenderLayerObjs.length() > 1) {
mArgs.usdModelRootOverridePath = SdfPath("/_BaseModel_");
}
}
// Switch to the default render layer unless the renderLayerMode is
// 'currentLayer', or the default layer is already the current layer.
if (mArgs.renderLayerMode != PxUsdExportJobArgsTokens->currentLayer &&
MFnRenderLayer::currentLayer() != MFnRenderLayer::defaultRenderLayer()) {
// Set the RenderLayer to the default render layer
MFnRenderLayer defaultLayer(MFnRenderLayer::defaultRenderLayer());
MGlobal::executeCommand(MString("editRenderLayerGlobals -currentRenderLayer ")+
defaultLayer.name(), false, false);
}
// Pre-process the argument dagPath path names into two sets. One set
// contains just the arg dagPaths, and the other contains all parents of
// arg dagPaths all the way up to the world root. Partial path names are
// enough because Maya guarantees them to still be unique, and they require
// less work to hash and compare than full path names.
TfHashSet<std::string, TfHash> argDagPaths;
TfHashSet<std::string, TfHash> argDagPathParents;
PxrUsdMayaUtil::ShapeSet::const_iterator end = mArgs.dagPaths.end();
for (PxrUsdMayaUtil::ShapeSet::const_iterator it = mArgs.dagPaths.begin();
it != end; ++it) {
MDagPath curDagPath = *it;
std::string curDagPathStr(curDagPath.partialPathName().asChar());
argDagPaths.insert(curDagPathStr);
while (curDagPath.pop() && curDagPath.length() >= 0) {
curDagPathStr = curDagPath.partialPathName().asChar();
if (argDagPathParents.find(curDagPathStr) != argDagPathParents.end()) {
// We've already traversed up from this path.
break;
}
argDagPathParents.insert(curDagPathStr);
}
}
// Now do a depth-first traversal of the Maya DAG from the world root.
// We keep a reference to arg dagPaths as we encounter them.
MDagPath curLeafDagPath;
for (MItDag itDag(MItDag::kDepthFirst, MFn::kInvalid); !itDag.isDone(); itDag.next()) {
MDagPath curDagPath;
itDag.getPath(curDagPath);
std::string curDagPathStr(curDagPath.partialPathName().asChar());
if (argDagPathParents.find(curDagPathStr) != argDagPathParents.end()) {
// This dagPath is a parent of one of the arg dagPaths. It should
// be included in the export, but not necessarily all of its
// children should be, so we continue to traverse down.
} else if (argDagPaths.find(curDagPathStr) != argDagPaths.end()) {
// This dagPath IS one of the arg dagPaths. It AND all of its
// children should be included in the export.
curLeafDagPath = curDagPath;
} else if (!MFnDagNode(curDagPath).hasParent(curLeafDagPath.node())) {
// This dagPath is not a child of one of the arg dagPaths, so prune
// it and everything below it from the traversal.
itDag.prune();
continue;
}
MayaPrimWriterPtr primWriter = nullptr;
if (!createPrimWriter(curDagPath, &primWriter) &&
curDagPath.length() > 0) {
// This dagPath and all of its children should be pruned.
itDag.prune();
continue;
}
if (primWriter) {
mMayaPrimWriterList.push_back(primWriter);
// Write out data (non-animated/default values).
if (UsdPrim usdPrim = primWriter->write(UsdTimeCode::Default())) {
MDagPath dag = primWriter->getDagPath();
mDagPathToUsdPathMap[dag] = usdPrim.GetPath();
// If we are merging transforms and the object derives from
// MayaTransformWriter but isn't actually a transform node, we
// need to add its parent.
if (mArgs.mergeTransformAndShape) {
MayaTransformWriterPtr xformWriter =
boost::dynamic_pointer_cast<MayaTransformWriter>(
primWriter);
if (xformWriter) {
MDagPath xformDag = xformWriter->getTransformDagPath();
mDagPathToUsdPathMap[xformDag] = usdPrim.GetPath();
}
}
mModelKindWriter.OnWritePrim(usdPrim, primWriter);
if (primWriter->shouldPruneChildren()) {
itDag.prune();
}
}
}
}
// Writing Materials/Shading
PxrUsdMayaTranslatorMaterial::ExportShadingEngines(
mStage,
mArgs.dagPaths,
mArgs.shadingMode,
mArgs.mergeTransformAndShape,
mArgs.usdModelRootOverridePath);
if (!mModelKindWriter.MakeModelHierarchy(mStage)) {
return false;
}
// now we populate the chasers and run export default
mChasers.clear();
PxrUsdMayaChaserRegistry::FactoryContext ctx(mStage, mDagPathToUsdPathMap, mArgs);
for (const std::string& chaserName : mArgs.chaserNames) {
if (PxrUsdMayaChaserRefPtr fn =
PxrUsdMayaChaserRegistry::GetInstance().Create(chaserName, ctx)) {
mChasers.push_back(fn);
}
else {
std::string error = TfStringPrintf("Failed to create chaser: %s",
chaserName.c_str());
MGlobal::displayError(MString(error.c_str()));
}
}
for (const PxrUsdMayaChaserRefPtr& chaser : mChasers) {
if (!chaser->ExportDefault()) {
return false;
}
}
return true;
}
MStatus AlembicExportCommand::doIt(const MArgList &args)
{
ESS_PROFILE_SCOPE("AlembicExportCommand::doIt");
MStatus status = MS::kFailure;
MTime currentAnimStartTime = MAnimControl::animationStartTime(),
currentAnimEndTime = MAnimControl::animationEndTime(),
oldCurTime = MAnimControl::currentTime(),
curMinTime = MAnimControl::minTime(),
curMaxTime = MAnimControl::maxTime();
MArgParser argData(syntax(), args, &status);
if (argData.isFlagSet("help")) {
// TODO: implement help for this command
// MGlobal::displayInfo(util::getHelpText());
return MS::kSuccess;
}
unsigned int jobCount = argData.numberOfFlagUses("jobArg");
MStringArray jobStrings;
if (jobCount == 0) {
// TODO: display dialog
MGlobal::displayError("[ExocortexAlembic] No jobs specified.");
MPxCommand::setResult(
"Error caught in AlembicExportCommand::doIt: no job specified");
return status;
}
else {
// get all of the jobstrings
for (unsigned int i = 0; i < jobCount; i++) {
MArgList jobArgList;
argData.getFlagArgumentList("jobArg", i, jobArgList);
jobStrings.append(jobArgList.asString(0));
}
}
// create a vector to store the jobs
std::vector<AlembicWriteJob *> jobPtrs;
double minFrame = 1000000.0;
double maxFrame = -1000000.0;
double maxSteps = 1;
double maxSubsteps = 1;
// init the curve accumulators
AlembicCurveAccumulator::Initialize();
try {
// for each job, check the arguments
bool failure = false;
for (unsigned int i = 0; i < jobStrings.length(); ++i) {
double frameIn = 1.0;
double frameOut = 1.0;
double frameSteps = 1.0;
double frameSubSteps = 1.0;
MString filename;
bool purepointcache = false;
bool normals = true;
bool uvs = true;
bool facesets = true;
bool bindpose = true;
bool dynamictopology = false;
bool globalspace = false;
bool withouthierarchy = false;
bool transformcache = false;
bool useInitShadGrp = false;
bool useOgawa = false; // Later, will need to be changed!
MStringArray objectStrings;
std::vector<std::string> prefixFilters;
std::set<std::string> attributes;
std::vector<std::string> userPrefixFilters;
std::set<std::string> userAttributes;
MObjectArray objects;
std::string search_str, replace_str;
// process all tokens of the job
MStringArray tokens;
jobStrings[i].split(';', tokens);
for (unsigned int j = 0; j < tokens.length(); j++) {
MStringArray valuePair;
tokens[j].split('=', valuePair);
if (valuePair.length() != 2) {
MGlobal::displayWarning(
"[ExocortexAlembic] Skipping invalid token: " + tokens[j]);
continue;
}
const MString &lowerValue = valuePair[0].toLowerCase();
if (lowerValue == "in") {
frameIn = valuePair[1].asDouble();
}
else if (lowerValue == "out") {
frameOut = valuePair[1].asDouble();
}
else if (lowerValue == "step") {
frameSteps = valuePair[1].asDouble();
}
else if (lowerValue == "substep") {
frameSubSteps = valuePair[1].asDouble();
}
else if (lowerValue == "normals") {
normals = valuePair[1].asInt() != 0;
}
else if (lowerValue == "uvs") {
uvs = valuePair[1].asInt() != 0;
}
else if (lowerValue == "facesets") {
facesets = valuePair[1].asInt() != 0;
}
else if (lowerValue == "bindpose") {
bindpose = valuePair[1].asInt() != 0;
}
else if (lowerValue == "purepointcache") {
purepointcache = valuePair[1].asInt() != 0;
}
else if (lowerValue == "dynamictopology") {
dynamictopology = valuePair[1].asInt() != 0;
}
else if (lowerValue == "globalspace") {
globalspace = valuePair[1].asInt() != 0;
}
else if (lowerValue == "withouthierarchy") {
withouthierarchy = valuePair[1].asInt() != 0;
}
else if (lowerValue == "transformcache") {
transformcache = valuePair[1].asInt() != 0;
}
else if (lowerValue == "filename") {
filename = valuePair[1];
}
else if (lowerValue == "objects") {
// try to find each object
valuePair[1].split(',', objectStrings);
}
else if (lowerValue == "useinitshadgrp") {
useInitShadGrp = valuePair[1].asInt() != 0;
}
// search/replace
else if (lowerValue == "search") {
search_str = valuePair[1].asChar();
}
else if (lowerValue == "replace") {
replace_str = valuePair[1].asChar();
}
else if (lowerValue == "ogawa") {
useOgawa = valuePair[1].asInt() != 0;
}
else if (lowerValue == "attrprefixes") {
splitListArg(valuePair[1], prefixFilters);
}
else if (lowerValue == "attrs") {
splitListArg(valuePair[1], attributes);
}
else if (lowerValue == "userattrprefixes") {
splitListArg(valuePair[1], userPrefixFilters);
}
else if (lowerValue == "userattrs") {
splitListArg(valuePair[1], userAttributes);
}
else {
MGlobal::displayWarning(
"[ExocortexAlembic] Skipping invalid token: " + tokens[j]);
continue;
}
}
// now check the object strings
for (unsigned int k = 0; k < objectStrings.length(); k++) {
MSelectionList sl;
MString objectString = objectStrings[k];
sl.add(objectString);
MDagPath dag;
for (unsigned int l = 0; l < sl.length(); l++) {
sl.getDagPath(l, dag);
MObject objRef = dag.node();
if (objRef.isNull()) {
MGlobal::displayWarning("[ExocortexAlembic] Skipping object '" +
objectStrings[k] + "', not found.");
break;
}
// get all parents
MObjectArray parents;
// check if this is a camera
bool isCamera = false;
for (unsigned int m = 0; m < dag.childCount(); ++m) {
MFnDagNode child(dag.child(m));
MFn::Type ctype = child.object().apiType();
if (ctype == MFn::kCamera) {
isCamera = true;
break;
}
}
if (dag.node().apiType() == MFn::kTransform && !isCamera &&
!globalspace && !withouthierarchy) {
MDagPath ppath = dag;
while (!ppath.node().isNull() && ppath.length() > 0 &&
ppath.isValid()) {
parents.append(ppath.node());
if (ppath.pop() != MStatus::kSuccess) {
break;
}
}
}
else {
parents.append(dag.node());
}
// push all parents in
while (parents.length() > 0) {
bool found = false;
for (unsigned int m = 0; m < objects.length(); m++) {
if (objects[m] == parents[parents.length() - 1]) {
found = true;
break;
}
}
if (!found) {
objects.append(parents[parents.length() - 1]);
}
parents.remove(parents.length() - 1);
}
// check all of the shapes below
if (!transformcache) {
sl.getDagPath(l, dag);
for (unsigned int m = 0; m < dag.childCount(); m++) {
MFnDagNode child(dag.child(m));
if (child.isIntermediateObject()) {
continue;
}
objects.append(child.object());
}
}
}
}
// check if we have incompatible subframes
if (maxSubsteps > 1.0 && frameSubSteps > 1.0) {
const double part = (frameSubSteps > maxSubsteps)
? (frameSubSteps / maxSubsteps)
: (maxSubsteps / frameSubSteps);
if (abs(part - floor(part)) > 0.001) {
MString frameSubStepsStr, maxSubstepsStr;
frameSubStepsStr.set(frameSubSteps);
maxSubstepsStr.set(maxSubsteps);
MGlobal::displayError(
"[ExocortexAlembic] You cannot combine substeps " +
frameSubStepsStr + " and " + maxSubstepsStr +
" in one export. Aborting.");
return MStatus::kInvalidParameter;
}
}
// remember the min and max values for the frames
if (frameIn < minFrame) {
minFrame = frameIn;
}
if (frameOut > maxFrame) {
maxFrame = frameOut;
}
if (frameSteps > maxSteps) {
maxSteps = frameSteps;
}
if (frameSteps > 1.0) {
frameSubSteps = 1.0;
}
if (frameSubSteps > maxSubsteps) {
maxSubsteps = frameSubSteps;
}
// check if we have a filename
if (filename.length() == 0) {
MGlobal::displayError("[ExocortexAlembic] No filename specified.");
for (size_t k = 0; k < jobPtrs.size(); k++) {
delete (jobPtrs[k]);
}
MPxCommand::setResult(
"Error caught in AlembicExportCommand::doIt: no filename "
"specified");
return MStatus::kFailure;
}
// construct the frames
MDoubleArray frames;
{
const double frameIncr = frameSteps / frameSubSteps;
for (double frame = frameIn; frame <= frameOut; frame += frameIncr) {
frames.append(frame);
}
}
AlembicWriteJob *job =
new AlembicWriteJob(filename, objects, frames, useOgawa,
prefixFilters, attributes, userPrefixFilters, userAttributes);
job->SetOption("exportNormals", normals ? "1" : "0");
job->SetOption("exportUVs", uvs ? "1" : "0");
job->SetOption("exportFaceSets", facesets ? "1" : "0");
job->SetOption("exportInitShadGrp", useInitShadGrp ? "1" : "0");
job->SetOption("exportBindPose", bindpose ? "1" : "0");
job->SetOption("exportPurePointCache", purepointcache ? "1" : "0");
job->SetOption("exportDynamicTopology", dynamictopology ? "1" : "0");
job->SetOption("indexedNormals", "1");
job->SetOption("indexedUVs", "1");
job->SetOption("exportInGlobalSpace", globalspace ? "1" : "0");
job->SetOption("flattenHierarchy", withouthierarchy ? "1" : "0");
job->SetOption("transformCache", transformcache ? "1" : "0");
// check if the search/replace strings are valid!
if (search_str.length() ? !replace_str.length()
: replace_str.length()) // either search or
// replace string is
// missing or empty!
{
ESS_LOG_WARNING(
"Missing search or replace parameter. No strings will be "
"replaced.");
job->replacer = SearchReplace::createReplacer();
}
else {
job->replacer = SearchReplace::createReplacer(search_str, replace_str);
}
// check if the job is satifsied
if (job->PreProcess() != MStatus::kSuccess) {
MGlobal::displayError("[ExocortexAlembic] Job skipped. Not satisfied.");
delete (job);
failure = true;
break;
}
// push the job to our registry
MGlobal::displayInfo("[ExocortexAlembic] Using WriteJob:" +
jobStrings[i]);
jobPtrs.push_back(job);
}
if (failure) {
for (size_t k = 0; k < jobPtrs.size(); k++) {
delete (jobPtrs[k]);
}
return MS::kFailure;
}
// compute the job count
unsigned int jobFrameCount = 0;
for (size_t i = 0; i < jobPtrs.size(); i++)
jobFrameCount += (unsigned int)jobPtrs[i]->GetNbObjects() *
(unsigned int)jobPtrs[i]->GetFrames().size();
// now, let's run through all frames, and process the jobs
const double frameRate = MTime(1.0, MTime::kSeconds).as(MTime::uiUnit());
const double incrSteps = maxSteps / maxSubsteps;
double nextFrame = minFrame + incrSteps;
for (double frame = minFrame; frame <= maxFrame;
frame += incrSteps, nextFrame += incrSteps) {
MAnimControl::setCurrentTime(MTime(frame / frameRate, MTime::kSeconds));
MAnimControl::setAnimationEndTime(
MTime(nextFrame / frameRate, MTime::kSeconds));
MAnimControl::playForward(); // this way, it forces Maya to play exactly
// one frame! and particles are updated!
AlembicCurveAccumulator::StartRecordingFrame();
for (size_t i = 0; i < jobPtrs.size(); i++) {
MStatus status = jobPtrs[i]->Process(frame);
if (status != MStatus::kSuccess) {
MGlobal::displayError("[ExocortexAlembic] Job aborted :" +
jobPtrs[i]->GetFileName());
for (size_t k = 0; k < jobPtrs.size(); k++) {
delete (jobPtrs[k]);
}
restoreOldTime(currentAnimStartTime, currentAnimEndTime, oldCurTime,
curMinTime, curMaxTime);
return status;
}
}
AlembicCurveAccumulator::StopRecordingFrame();
}
}
catch (...) {
MGlobal::displayError(
"[ExocortexAlembic] Jobs aborted, force closing all archives!");
for (std::vector<AlembicWriteJob *>::iterator beg = jobPtrs.begin();
beg != jobPtrs.end(); ++beg) {
(*beg)->forceCloseArchive();
}
restoreOldTime(currentAnimStartTime, currentAnimEndTime, oldCurTime,
curMinTime, curMaxTime);
MPxCommand::setResult("Error caught in AlembicExportCommand::doIt");
status = MS::kFailure;
}
MAnimControl::stop();
AlembicCurveAccumulator::Destroy();
// restore the animation start/end time and the current time!
restoreOldTime(currentAnimStartTime, currentAnimEndTime, oldCurTime,
curMinTime, curMaxTime);
// delete all jobs
for (size_t k = 0; k < jobPtrs.size(); k++) {
delete (jobPtrs[k]);
}
// remove all known archives
deleteAllArchives();
return status;
}
// ========== DtCameraGetMatrix ==========
//
// SYNOPSIS
// Return the camera transformation matrix. This matrix
// includes the camera rotation, translation, and scale
// transforms. This function also sets the valid bits
// for DT_CAMERA_POSITION and DT_CAMERA_ORIENTATION.
// The matrix is in row-major order.
//
// From PA DT:
// Not implemented: returns a pointer to an identity matrix
// under the OpenModel implementation.
//
// For Maya DT:
// This fuction returns the camera's global transformation matrix.
//
int DtCameraGetMatrix( int cameraID,
float** matrix )
{
// static float mtx[4][4];
static float globalMtx[4][4];
static float localMtx[4][4];
// Check for error.
//
if( ( cameraID < 0) || ( cameraID >= local->camera_ct ) )
{
*matrix = NULL;
return( 0 );
}
// Set the valid flag.
//
// local->cameras[cameraID].valid_bits|=(DT_VALID_BIT_MASK&DT_CAMERA_MATRIX);
// Get transformations.
//
#if 0
mtx[0][0]=1.0;mtx[0][1]=0.0;mtx[0][2]=0.0;mtx[0][3]=0.0;
mtx[1][0]=0.0;mtx[1][1]=1.0;mtx[1][2]=0.0;mtx[1][3]=0.0;
mtx[2][0]=0.0;mtx[2][1]=0.0;mtx[2][2]=1.0;mtx[2][3]=0.0;
mtx[3][0]=0.0;mtx[3][1]=0.0;mtx[3][2]=0.0;mtx[3][3]=1.0;
#endif
// Camera transformation matrix is set on the transform node.
//
MStatus returnStatus = MS::kSuccess;
MFnDagNode fnTransNode( local->cameras[cameraID].transformNode, &returnStatus );
MDagPath dagPath;
returnStatus = fnTransNode.getPath( dagPath );
if( MS::kSuccess == returnStatus )
{
if( DtExt_Debug() & DEBUG_CAMERA )
{
cerr << "Got the dagPath\n";
cerr << "length of the dagpath is " << dagPath.length() << endl;
}
}
MFnDagNode fnDagPath( dagPath, &returnStatus );
MMatrix localMatrix;
MMatrix globalMatrix;
localMatrix = fnTransNode.transformationMatrix ( &returnStatus );
globalMatrix = dagPath.inclusiveMatrix();
localMatrix.get( localMtx );
globalMatrix.get( globalMtx );
if( DtExt_Debug() & DEBUG_CAMERA )
{
int i = 0;
int j = 0;
cerr << "camera's global transformation matrix:\n";
for( i = 0; i < 4; i++ )
{
for( j = 0; j < 4; j++ )
{
cerr << globalMtx[i][j] << " ";
}
cerr << endl;
}
cerr << "camera's local transformation matrix:\n";
for( i = 0; i < 4; i++ )
{
for( j = 0; j < 4; j++ )
{
cerr << localMtx[i][j] << " ";
}
cerr << endl;
}
}
// *matrix = (float*)&mtx;
*matrix = (float*)&globalMtx;
return(1);
} // DtCameraGetMatrix //
// ------------------------------------------------------------
bool SceneGraph::retrieveExportNodes()
{
// Create a selection list containing only the root nodes (implies export all!)
MSelectionList allTargets;
for ( MItDag it ( MItDag::kBreadthFirst );
it.depth()<=1 && it.item()!=MObject::kNullObj;
it.next() )
{
MDagPath path;
MStatus status = it.getPath ( path );
String pathName = path.fullPathName().asChar();
// Attach a function set
MFnDependencyNode fn ( path.node() );
String theNodeName = fn.name().asChar();
// Check if it's the world node
if ( it.depth() == 0 ) continue;
if ( status == MStatus::kSuccess )
{
if ( mExportSelectedOnly )
allTargets.add ( path );
else
mTargets.add ( path );
}
}
// now fill in the targets, either the same as allTargets, or it is export selection only
if ( mExportSelectedOnly )
{
// Export the selection:
// Grab the selected DAG components
if ( MStatus::kFailure == MGlobal::getActiveSelectionList ( mTargets ) )
{
std::cerr << "MGlobal::getActiveSelectionList" << std::endl;
return false;
}
// For all the non-transforms selected, make sure to extend to the transforms underneath.
MDagPathArray additions;
MIntArray removals;
for ( uint32 i = 0; i < mTargets.length(); ++i )
{
MDagPath itemPath;
mTargets.getDagPath ( i, itemPath );
if ( !itemPath.node().hasFn ( MFn::kTransform ) )
{
MDagPath transformPath = itemPath;
while ( transformPath.length() > 0 )
{
transformPath.pop();
if ( !mTargets.hasItem ( transformPath ) )
{
additions.append ( transformPath );
break;
}
}
removals.append ( i );
}
}
for ( uint32 i = 0; i < removals.length(); ++i ) mTargets.remove ( removals[i] - i );
for ( uint32 i = 0; i < additions.length(); ++i ) mTargets.add ( additions[i] );
// Add all the forced nodes to the list.
uint32 forceNodeCount = mForcedNodes.length();
for ( uint32 i = 0; i < forceNodeCount; ++i )
{
MDagPath p = mForcedNodes[i];
if ( mTargets.hasItem ( p ) ) continue;
mTargets.add ( p );
}
// Add additional selection paths for any objects in our
// selection which have been instanced (either directly, or
// via instancing of an ancestor) - as otherwise, the selection
// will only include ONE of the DAG paths
//
addInstancedDagPaths ( mTargets );
// remove any selected nodes CONTAINED within other selected
// hierarchies (to ensure we don't export subtrees multiple times)
//
removeMultiplyIncludedDagPaths ( mTargets );
}
return true;
}
// --------------------------------------------------------------------
MStatus SceneGraph::removeMultiplyIncludedDagPaths ( MSelectionList& selectionList )
{
// As we're potentially deleting elements out of the selection list
// it's easiest to avoid array bound check issues by walking the
// list backwards.
MStatus status;
int length=selectionList.length ( &status );
if ( status != MStatus::kSuccess )
return MStatus::kFailure;
for ( int i = length - 1; i >= 0; --i )
{
MDagPath dagIPath;
if ( selectionList.getDagPath ( i, dagIPath ) != MStatus::kSuccess )
return MStatus::kFailure;
uint dagIdepth = dagIPath.length();
for ( int j = i - 1; j >= 0; --j )
{
MDagPath dagJPath;
if ( selectionList.getDagPath ( j, dagJPath ) != MStatus::kSuccess )
return MStatus::kFailure;
// Test if the longer of these two dag paths contains the shorter ...
uint dagJdepth = dagJPath.length();
if ( dagJdepth >= dagIdepth )
{
bool isParent = false;
for ( int depth = dagIdepth - 1; depth > 0 && !isParent; --depth )
{
dagJPath.pop();
isParent = dagJPath.node() == dagIPath.node();
}
if ( isParent )
{
selectionList.remove ( j );
i--;
}
}
else
{
bool isParent = false;
MDagPath dagIt = dagIPath;
for ( int depth = dagIdepth - 1; depth > 0 && !isParent; --depth )
{
dagIt.pop();
isParent = dagJPath.node() == dagIt.node();
}
if ( isParent )
{
selectionList.remove ( i );
break;
}
}
}
}
return MStatus::kSuccess;
}
// --------------------------------------------------------------------
bool SceneGraph::getIsExportNode (
const MDagPath& dagPath,
bool& isForced,
bool& isVisible )
{
// Does this dagPath already exist? If so, only recurse if FollowInstancedChildren() is set.
MFnDagNode dagFn ( dagPath );
String dagNodeName = dagFn.name().asChar();
bool isSceneRoot = dagPath.length() == 0;
// Ignore default and intermediate nodes (history items)
bool isIntermediateObject = dagFn.isIntermediateObject();
if ( ( dagFn.isDefaultNode() && !isSceneRoot ) || isIntermediateObject )
{
return false;
}
MString nodeName = dagPath.partialPathName();
if ( nodeName == MString ( NIMA_INTERNAL_PHYSIKS ) )
{
// Skip this node, which is only used
// by Nima as a work-around for a Maya bug.
return false;
}
// If we are not already forcing this node, its children
// check whether we should be forcing it (skinning of hidden joints).
isForced = isForcedNode ( dagPath );
DagHelper::getPlugValue ( dagPath.node(), ATTR_VISIBILITY, isVisible );
bool isInstanced = dagPath.isInstanced();
uint instanceNumber = dagPath.instanceNumber();
if ( !isForced )
{
// Check for visibility
if ( !ExportOptions::exportInvisibleNodes() && !isVisible )
{
// Check if the visibility of the element is animated.
AnimationSampleCache* animationCache = mDocumentExporter->getAnimationCache();
if ( !AnimationHelper::isAnimated ( animationCache, dagPath.node(), ATTR_VISIBILITY ) )
{
return false;
}
}
else if ( !isVisible && !ExportOptions::exportDefaultCameras() )
{
// Check for the default camera transform names.
if ( nodeName == CAMERA_PERSP || nodeName == CAMERA_TOP || nodeName == CAMERA_SIDE || nodeName == CAMERA_FRONT ||
nodeName == CAMERA_PERSP_SHAPE || nodeName == CAMERA_TOP_SHAPE || nodeName == CAMERA_SIDE_SHAPE || nodeName == CAMERA_FRONT_SHAPE )
return false;
}
}
isForced &= !isVisible;
if ( !isForced )
{
// We don't want to process manipulators
if ( dagPath.hasFn ( MFn::kManipulator ) || dagPath.hasFn ( MFn::kViewManip ) ) return false;
// Check for constraints which are not exported
//if ( !ExportOptions::exportConstraints() && dagPath.hasFn ( MFn::kConstraint ) ) return false;
if ( dagPath.hasFn ( MFn::kConstraint ) ) return false;
// Check set membership exclusion/inclusion
if ( SetHelper::isExcluded ( dagPath ) ) return false;
}
return true;
}
// --------------------------------------
void ReferenceManager::processReference ( const MObject& referenceNode )
{
MStatus status;
MFnDependencyNode referenceNodeFn ( referenceNode, &status );
if (status != MStatus::kSuccess) return;
#if MAYA_API_VERSION >= 600
MString referenceNodeName = MFnDependencyNode( referenceNode ).name();
Reference* reference = new Reference();
reference->referenceNode = referenceNode;
mReferences.push_back ( reference );
// Get the paths of the root transforms included in this reference
MObjectArray subReferences;
getRootObjects ( referenceNode, reference->paths, subReferences );
uint pathCount = reference->paths.length();
// Process the sub-references first
uint subReferenceCount = subReferences.length();
for (uint i = 0; i < subReferenceCount; ++i)
{
MObject& subReference = subReferences[i];
if ( subReference != MObject::kNullObj ) processReference ( subReference );
}
// Retrieve the reference node's filename
MString command = MString("reference -rfn \"") + referenceNodeFn.name() + MString("\" -q -filename;");
MString filename;
status = MGlobal::executeCommand ( command, filename );
if (status != MStatus::kSuccess || filename.length() == 0) return;
// Strip the filename of the multiple file token
int stripIndex = filename.index('{');
if (stripIndex != -1) filename = filename.substring(0, stripIndex - 1);
// Avoid transform look-ups on COLLADA references.
int extLocation = filename.rindex('.');
if (extLocation > 0)
{
MString ext = filename.substring(extLocation + 1, filename.length() - 1).toLowerCase();
if (ext == "dae" || ext == "xml") return;
}
// Check for already existing file information
// Otherwise create a new file information sheet with current node names
for ( ReferenceFileList::iterator it = mFiles.begin(); it != mFiles.end(); ++it )
{
if ((*it)->filename == filename)
{
reference->file = (*it);
break;
}
}
if ( reference->file == NULL ) reference->file = processReferenceFile(filename);
// Get the list of the root transform's first child's unreferenced parents.
// This is a list of the imported nodes!
for (uint j = 0; j < pathCount; ++j)
{
MDagPath path = reference->paths[j];
if (path.childCount() > 0)
{
path.push ( path.child(0) );
MFnDagNode childNode ( path );
if (!childNode.object().hasFn(MFn::kTransform)) continue;
uint parentCount = childNode.parentCount();
for (uint k = 0; k < parentCount; ++k)
{
MFnDagNode parentNode(childNode.parent(k));
if (parentNode.object() == MObject::kNullObj || parentNode.isFromReferencedFile()) continue;
MDagPath parentPath = MDagPath::getAPathTo(parentNode.object());
if (parentPath.length() > 0)
{
ReferenceRootList::iterator it =
reference->reroots.insert( reference->reroots.end(), ReferenceRoot() );
(*it).index = j;
(*it).reroot = parentPath;
}
}
}
}
#endif
}
AbcWriteJob::AbcWriteJob(const char * iFileName,
bool iAsOgawa,
std::set<double> & iTransFrames,
Alembic::AbcCoreAbstract::TimeSamplingPtr iTransTime,
std::set<double> & iShapeFrames,
Alembic::AbcCoreAbstract::TimeSamplingPtr iShapeTime,
const JobArgs & iArgs)
{
MStatus status;
mFileName = iFileName;
mAsOgawa = iAsOgawa;
mBoxIndex = 0;
mArgs = iArgs;
mShapeSamples = 1;
mTransSamples = 1;
if (mArgs.useSelectionList)
{
bool emptyDagPaths = mArgs.dagPaths.empty();
// get the active selection
MSelectionList activeList;
MGlobal::getActiveSelectionList(activeList);
mSList = activeList;
unsigned int selectionSize = activeList.length();
for (unsigned int index = 0; index < selectionSize; index ++)
{
MDagPath dagPath;
status = activeList.getDagPath(index, dagPath);
if (status == MS::kSuccess)
{
unsigned int length = dagPath.length();
while (--length)
{
dagPath.pop();
mSList.add(dagPath, MObject::kNullObj, true);
}
if (emptyDagPaths)
{
mArgs.dagPaths.insert(dagPath);
}
}
}
}
mTransFrames = iTransFrames;
mShapeFrames = iShapeFrames;
// only needed during creation of the transforms and shapes
mTransTime = iTransTime;
mTransTimeIndex = 0;
mShapeTime = iShapeTime;
mShapeTimeIndex = 0;
// should have at least 1 value
assert(!mTransFrames.empty() && !mShapeFrames.empty());
mFirstFrame = *(mTransFrames.begin());
std::set<double>::iterator last = mTransFrames.end();
last--;
mLastFrame = *last;
last = mShapeFrames.end();
last--;
double lastShapeFrame = *last;
if (lastShapeFrame > mLastFrame)
mLastFrame = lastShapeFrame;
}
void maTranslator::writeDagNodes(fstream& f)
{
fParentingRequired.clear();
MItDag dagIter;
dagIter.traverseUnderWorld(true);
MDagPath worldPath;
dagIter.getPath(worldPath);
//
// We step over the world node before starting the loop, because it
// doesn't get written out.
//
for (dagIter.next(); !dagIter.isDone(); dagIter.next())
{
MDagPath path;
dagIter.getPath(path);
//
// If the node has already been written, then all of its descendants
// must have been written, or at least checked, as well, so prune
// this branch of the tree from the iteration.
//
MFnDagNode dagNodeFn(path);
if (dagNodeFn.isFlagSet(fCreateFlag))
{
dagIter.prune();
continue;
}
//
// If this is a default node, it will be written out later, so skip
// it.
//
if (dagNodeFn.isDefaultNode()) continue;
//
// If this node is not writable, and is not a shared node, then mark
// it as having been written, and skip it.
//
if (!dagNodeFn.canBeWritten() && !dagNodeFn.isShared())
{
dagNodeFn.setFlag(fCreateFlag, true);
continue;
}
unsigned int numParents = dagNodeFn.parentCount();
if (dagNodeFn.isFromReferencedFile())
{
//
// We don't issue 'creatNode' commands for nodes from referenced
// files, but if the node has any parents which are not from
// referenced files, other than the world, then make a note that
// we'll need to issue extra 'parent' commands for it later on.
//
unsigned int i;
for (i = 0; i < numParents; i++)
{
MObject altParent = dagNodeFn.parent(i);
MFnDagNode altParentFn(altParent);
if (!altParentFn.isFromReferencedFile()
&& (altParentFn.object() != worldPath.node()))
{
fParentingRequired.append(path);
break;
}
}
}
else
{
//
// Find the node's parent.
//
MDagPath parentPath = worldPath;
if (path.length() > 1)
{
//
// Get the parent's path.
//
parentPath = path;
parentPath.pop();
//
// If the parent is in the underworld, then find the closest
// ancestor which is not.
//
if (parentPath.pathCount() > 1)
{
//
// The first segment of the path contains whatever
// portion of the path exists in the world. So the closest
// worldly ancestor is simply the one at the end of that
// first path segment.
//
path.getPath(parentPath, 0);
}
}
MFnDagNode parentNodeFn(parentPath);
if (parentNodeFn.isFromReferencedFile())
{
//
// We prefer to parent to a non-referenced node. So if this
// node has any other parents, which are not from referenced
// files and have not already been processed, then we'll
// skip this instance and wait for an instance through one
// of those parents.
//
unsigned i;
for (i = 0; i < numParents; i++)
{
if (dagNodeFn.parent(i) != parentNodeFn.object())
{
MObject altParent = dagNodeFn.parent(i);
MFnDagNode altParentFn(altParent);
if (!altParentFn.isFromReferencedFile()
&& !altParentFn.isFlagSet(fCreateFlag))
{
break;
}
}
}
if (i < numParents) continue;
//
// This node only has parents within referenced files, so
// create it without a parent and note that we need to issue
// 'parent' commands for it later on.
//
writeCreateNode(f, path, worldPath);
fParentingRequired.append(path);
}
else
{
writeCreateNode(f, path, parentPath);
//
// Let's see if this node has any parents from referenced
// files, or any parents other than this one which are not
// from referenced files.
//
unsigned int i;
bool hasRefParents = false;
bool hasOtherNonRefParents = false;
for (i = 0; i < numParents; i++)
{
if (dagNodeFn.parent(i) != parentNodeFn.object())
{
MObject altParent = dagNodeFn.parent(i);
MFnDagNode altParentFn(altParent);
if (altParentFn.isFromReferencedFile())
hasRefParents = true;
else
hasOtherNonRefParents = true;
//
// If we've already got positives for both tests,
// then there's no need in continuing.
//
if (hasRefParents && hasOtherNonRefParents) break;
}
}
//
// If this node has parents from referenced files, then
// make note that we will have to issue 'parent' commands
// later on.
//
if (hasRefParents) fParentingRequired.append(path);
//
// If this node has parents other than this one which are
// not from referenced files, then make note that the
// parenting for the other instances still has to be done.
//
if (hasOtherNonRefParents)
{
fInstanceChildren.append(path);
fInstanceParents.append(parentPath);
}
}
//
// Write out the node's 'addAttr', 'setAttr' and 'lockNode'
// commands.
//
writeNodeAttrs(f, path.node(), true);
writeLockNode(f, path.node());
}
//
// Mark the node as having been written.
//
dagNodeFn.setFlag(fCreateFlag, true);
}
//
// Write out the parenting for instances.
//
writeInstances(f);
}
MStatus CIKSolverNode::doSimpleSolver()
{
MStatus stat;
// Get the handle and create a function set for it
//
MIkHandleGroup* handle_group = handleGroup();
if (NULL == handle_group) {
return MS::kFailure;
}
MObject handle = handle_group->handle(0);
MDagPath handlePath = MDagPath::getAPathTo(handle);
MFnIkHandle fnHandle(handlePath, &stat);
// End-Effector
MDagPath endEffectorPath;
fnHandle.getEffector(endEffectorPath);
MFnIkEffector fnEffector(endEffectorPath);
MPoint effectorPos = fnEffector.rotatePivot(MSpace::kWorld);
unsigned int numJoints = endEffectorPath.length();
std::vector<MDagPath> jointsDagPaths; jointsDagPaths.reserve(numJoints);
while (endEffectorPath.length() > 1)
{
endEffectorPath.pop();
jointsDagPaths.push_back( endEffectorPath );
}
std::reverse(jointsDagPaths.begin(), jointsDagPaths.end());
static bool builtLocalSkeleton = false;
if (builtLocalSkeleton == false)
{
for (int jointIdx = 0; jointIdx < jointsDagPaths.size(); ++jointIdx)
{
MFnIkJoint curJoint(jointsDagPaths[jointIdx]);
m_localJointsPos.push_back( curJoint.getTranslation(MSpace::kWorld) );
}
m_localJointsPos.push_back(effectorPos );
builtLocalSkeleton = true;
}
MPoint startJointPos = MFnIkJoint(jointsDagPaths.front()).getTranslation(MSpace::kWorld);
MVector startToEndEff = m_localJointsPos.back() - m_localJointsPos.front();
double curveLength = (getPosition(1.0) - getPosition(0.0)).length();
double chainLength = startToEndEff.length(); // in local space.
double stretchFactor = curveLength / chainLength;
double uVal = 0.0f;
MVector jointPosL = m_localJointsPos[0];
for (int jointIdx = 0; jointIdx < jointsDagPaths.size(); ++jointIdx)
{
MFnIkJoint curJoint(jointsDagPaths[jointIdx]);
MVector curJointPosL = m_localJointsPos[jointIdx];
double dist = stretchFactor * (curJointPosL - jointPosL).length();
uVal = uVal + dist / curveLength;
MVector curCurveJointPos = getPosition(uVal);
curJoint.setTranslation(curCurveJointPos, MSpace::kWorld);
jointPosL = curJointPosL;
}
MVector effectorCurvePos = getPosition(1.0);
MVector curCurveJointPos = getPosition(uVal);
MVector effectorVec = (effectorCurvePos - curCurveJointPos).normal();
double endJointAngle[3];
MVector effectorVecXY = MVector(effectorVec(0), effectorVec(1), 0.0);
endJointAngle[2] = effectorVecXY.angle(MVector(1, 0, 0));
if ((MVector(1, 0, 0) ^ effectorVecXY) * MVector(0, 0, 1) < 0.0) { endJointAngle[2] = -endJointAngle[2]; }
MVector effectorVecXZ = MVector(effectorVec(0), 0.0, effectorVec(2));
endJointAngle[1] = effectorVecXZ.angle(MVector(1, 0, 0));
if ((MVector(1, 0, 0) ^ effectorVecXZ) * MVector(0, 1, 0) < 0.0) { endJointAngle[1] = -endJointAngle[1]; }
endJointAngle[0] = 0.0;
MFnIkJoint curJoint(jointsDagPaths.back()); curJoint.setRotation(endJointAngle, curJoint.rotationOrder());
return MS::kSuccess;
}