static void restoreOldTime(MTime &start, MTime &end, MTime &curr, MTime &minT,
MTime &maxT)
{
const double st = start.as(start.unit()), en = end.as(end.unit()),
cu = curr.as(curr.unit()), mi = minT.as(minT.unit()),
ma = maxT.as(maxT.unit());
MString inst = "playbackOptions -ast ";
inst += st;
inst += " -aet ";
inst += en;
inst += " -min ";
inst += mi;
inst += " -max ";
inst += ma;
inst += ";\ncurrentTime ";
inst += cu;
inst += ";";
MGlobal::executeCommand(inst);
}
bool
atomExport::setUpCache(MSelectionList &sList, std::vector<atomCachedPlugs *> &cachedPlugs,atomAnimLayers &animLayers,
bool sdk, bool constraint, bool layers,
std::set<std::string> &attrStrings, atomTemplateReader &templateReader,
MTime &startTime, MTime &endTime, MAngle::Unit angularUnit,
MDistance::Unit linearUnit)
{
if(endTime<startTime)
return false; //should never happen but just in case.
unsigned int numObjects = sList.length();
cachedPlugs.resize(numObjects);
double dStart = startTime.value();
double dEnd = endTime.value() + (.0000001); //little nudge in case of round off errors
MTime::Unit unit = startTime.unit();
double tickStep = MTime(1.0,unit).value();
unsigned int numItems = ((unsigned int)((dEnd - dStart)/tickStep)) + 1;
bool somethingIsCached = false; //if nothing get's cached no reason to run computation loop
for (unsigned int i = 0; i < numObjects; i++)
{
atomCachedPlugs *plug = NULL;
//make sure it's a NULL, and preset it in case we skip this node
cachedPlugs[i] = plug;
MDagPath path;
MObject node;
MString name;
if (sList.getDagPath (i, path) == MS::kSuccess)
{
node = path.node();
name = path.partialPathName();
}
else if (sList.getDependNode (i, node) == MS::kSuccess) {
if (!node.hasFn (MFn::kDependencyNode)) {
continue;
}
MFnDependencyNode fnNode (node);
name = fnNode.name();
}
if(node.isNull()==false)
{
if(i< animLayers.length())
{
MPlugArray plugs;
animLayers.getPlugs(i,plugs);
std::set<std::string> tempAttrStrings;
atomTemplateReader tempTemplateReader;
plug = new atomCachedPlugs(name,node,plugs,sdk,constraint,layers,
tempAttrStrings,tempTemplateReader,numItems,angularUnit,
linearUnit);
if(plug->hasCached() ==false)
delete plug;
else
{
cachedPlugs[i] = plug;
somethingIsCached = true;
}
}
else
{
if(templateReader.findNode(name)== false)
{
continue;
}
MSelectionList localList;
localList.add(node);
MPlugArray animatablePlugs;
MAnimUtil::findAnimatablePlugs(localList,animatablePlugs);
plug = new atomCachedPlugs(name,node,animatablePlugs,sdk,constraint,layers,attrStrings,templateReader,numItems,angularUnit,
linearUnit);
if(plug->hasCached() ==false)
delete plug;
else
{
cachedPlugs[i] = plug;
somethingIsCached = true;
}
}
}
}
bool computationFinished = true; //if no interrupt happens we will finish the computation
if(somethingIsCached)
{
bool hasActiveProgress = false;
if (MProgressWindow::reserve()) {
hasActiveProgress = true;
MProgressWindow::setInterruptable(true);
MProgressWindow::startProgress();
MProgressWindow::setProgressRange(0, numObjects);
MProgressWindow::setProgress(0);
MStatus stringStat;
MString msg = MStringResource::getString(kBakingProgress, stringStat);
if(stringStat == MS::kSuccess)
MProgressWindow::setTitle(msg);
}
unsigned int count =0;
for(double tick = dStart; tick <= dEnd; tick += tickStep)
{
if(hasActiveProgress)
MProgressWindow::setProgress(count);
MTime time(tick,unit);
MDGContext ctx(time);
for(unsigned int z = 0; z< cachedPlugs.size(); ++z)
{
if(cachedPlugs[z])
cachedPlugs[z]->calculateValue(ctx,count);
}
if (hasActiveProgress && MProgressWindow::isCancelled())
{
computationFinished = false;
break;
}
++count;
}
if(hasActiveProgress)
MProgressWindow::endProgress();
}
return computationFinished;
}