// removes instance of a motion from all runtime structures, but does // not erase entry by ID, as this could be a duplicate instance // use removeMotion(id) to remove a reference to a given motion by id // (that will not remove (active) deprecated motions). void LLMotionController::removeMotionInstance(LLMotion* motionp) { if (motionp) { llassert(findMotion(motionp->getID()) != motionp); mLoadingMotions.erase(motionp); mLoadedMotions.erase(motionp); mActiveMotions.remove(motionp); //<singu> // Deactivation moved here. Only delete motionp when it is being removed from mDeprecatedMotions. if (motionp->isActive()) { motionp->deactivate(); // If a motion is deactivated, it must be removed from mDeprecatedMotions if there. motion_set_t::iterator found_it = mDeprecatedMotions.find(motionp); if (found_it != mDeprecatedMotions.end()) { mDeprecatedMotions.erase(found_it); // If a motion is erased from mDeprecatedMotions, it must be deleted. delete motionp; } } //</singu> } }
//----------------------------------------------------------------------------- // stopMotionLocally() //----------------------------------------------------------------------------- BOOL LLMotionController::stopMotionLocally(const LLUUID &id, BOOL stop_immediate) { // if already inactive, return false LLMotion *motion = findMotion(id); if (!motion) { return FALSE; } // If on active list, stop it if (isMotionActive(motion) && !motion->isStopped()) { // when using timesteps, set stop time to last frame's time, otherwise grab current timer value // *FIX: should investigate this inconsistency...hints of obscure bugs F32 stop_time = (mTimeStep != 0.f || mPaused) ? (mTime) : mTimeOffset + (mTimer.getElapsedTimeF32() * mTimeFactor); motion->setStopTime(stop_time); if (stop_immediate) { deactivateMotion(motion, false); } return TRUE; } else if (isMotionLoading(motion)) { motion->setStopped(TRUE); return TRUE; } return FALSE; }
//----------------------------------------------------------------------------- // purgeExcessMotion() //----------------------------------------------------------------------------- void LLMotionController::purgeExcessMotions() { if (mLoadedMotions.size() > MAX_MOTION_INSTANCES) { // clean up deprecated motions for (motion_set_t::iterator deprecated_motion_it = mDeprecatedMotions.begin(); deprecated_motion_it != mDeprecatedMotions.end(); ) { motion_set_t::iterator cur_iter = deprecated_motion_it++; LLMotion* cur_motionp = *cur_iter; if (!isMotionActive(cur_motionp)) { // Motion is deprecated so we know it's not cannonical, // we can safely remove the instance removeMotionInstance(cur_motionp); // modifies mDeprecatedMotions mDeprecatedMotions.erase(cur_iter); } } } std::set<LLUUID> motions_to_kill; if (mLoadedMotions.size() > MAX_MOTION_INSTANCES) { // too many motions active this frame, kill all blenders mPoseBlender.clearBlenders(); for (motion_set_t::iterator loaded_motion_it = mLoadedMotions.begin(); loaded_motion_it != mLoadedMotions.end(); ++loaded_motion_it) { LLMotion* cur_motionp = *loaded_motion_it; // motion isn't playing, delete it if (!isMotionActive(cur_motionp)) { motions_to_kill.insert(cur_motionp->getID()); } } } // clean up all inactive, loaded motions for (std::set<LLUUID>::iterator motion_it = motions_to_kill.begin(); motion_it != motions_to_kill.end(); ++motion_it) { // look up the motion again by ID to get canonical instance // and kill it only if that one is inactive LLUUID motion_id = *motion_it; LLMotion* motionp = findMotion(motion_id); if (motionp && !isMotionActive(motionp)) { removeMotion(motion_id); } } if (mLoadedMotions.size() > 2*MAX_MOTION_INSTANCES) { LL_WARNS_ONCE("Animation") << "> " << 2*MAX_MOTION_INSTANCES << " Loaded Motions" << llendl; } }
void Process::step() { QTime time; time.start(); switch (mode) { case ProcessNone: break; case ProcessColor: findColor(); findClusters(hitImage, areas); transform2DAreas(areas); findSeqAreas(areas, seqAreas); filterSeqAreas(seqAreas, seqAreasBuffer); break; case ProcessMotion: findMotion(); findClusters(hitImage, areas); transform2DAreas(areas); findSeqAreas(areas, seqAreas); filterSeqAreas(seqAreas, seqAreasBuffer); cvCopy(image, prevImage); break; case ProcessHaar: findHaar(); findSeqAreas(areas, seqAreas); filterSeqAreas(seqAreas, seqAreasBuffer); break; case ProcessContour: findContours(); findClusters(hitImage, areas); transform2DAreas(areas); findSeqAreas(areas, seqAreas); filterSeqAreas(seqAreas, seqAreasBuffer); break; case ProcessHoughCircles: findHoughCircles(); findSeqAreas(areas, seqAreas); filterSeqAreas(seqAreas, seqAreasBuffer); break; } timeMean += time.elapsed(); timeNum++; if ( timeNum == 10 ) { //qDebug() << "Process time:" << timeMean/10; timeMean = 0; timeNum = 0; } }
//----------------------------------------------------------------------------- // removeMotion() //----------------------------------------------------------------------------- void LLMotionController::removeMotion( const LLUUID& id) { LLMotion* motionp = findMotion(id); //<singu> // If a motion is erased from mAllMotions, it must be deleted. if (motionp) { mAllMotions.erase(id); removeMotionInstance(motionp); delete motionp; } //</singu> }
// removes instance of a motion from all runtime structures, but does // not erase entry by ID, as this could be a duplicate instance // use removeMotion(id) to remove all references to a given motion by id. void LLMotionController::removeMotionInstance(LLMotion* motionp) { if (motionp) { llassert(findMotion(motionp->getID()) != motionp); if (motionp->isActive()) motionp->deactivate(); mLoadingMotions.erase(motionp); mLoadedMotions.erase(motionp); mActiveMotions.remove(motionp); delete motionp; } }
//----------------------------------------------------------------------------- // purgeExcessMotion() //----------------------------------------------------------------------------- void LLMotionController::purgeExcessMotions() { //<singu> // The old code attempted to remove non-active motions from mDeprecatedMotions, // but that is nonsense: there are no motions in mDeprecatedMotions that are not active. if (mLoadedMotions.size() <= MAX_MOTION_INSTANCES) { // Speed up, no need to create motions_to_kill. return; } //</singu> std::set<LLUUID> motions_to_kill; if (1) // Singu: leave indentation alone... { // too many motions active this frame, kill all blenders mPoseBlender.clearBlenders(); for (motion_set_t::iterator loaded_motion_it = mLoadedMotions.begin(); loaded_motion_it != mLoadedMotions.end(); ++loaded_motion_it) { LLMotion* cur_motionp = *loaded_motion_it; // motion isn't playing, delete it if (!isMotionActive(cur_motionp)) { motions_to_kill.insert(cur_motionp->getID()); } } } // clean up all inactive, loaded motions for (std::set<LLUUID>::iterator motion_it = motions_to_kill.begin(); motion_it != motions_to_kill.end(); ++motion_it) { // look up the motion again by ID to get canonical instance // and kill it only if that one is inactive LLUUID motion_id = *motion_it; LLMotion* motionp = findMotion(motion_id); if (motionp && !isMotionActive(motionp)) { removeMotion(motion_id); } } if (mLoadedMotions.size() > 2*MAX_MOTION_INSTANCES) { LL_WARNS_ONCE("Animation") << "> " << 2*MAX_MOTION_INSTANCES << " Loaded Motions" << llendl; } }
//----------------------------------------------------------------------------- // startMotion() //----------------------------------------------------------------------------- BOOL LLMotionController::startMotion(const LLUUID &id, F32 start_offset) { // do we have an instance of this motion for this character? LLMotion *motion = findMotion(id); // motion that is stopping will be allowed to stop but // replaced by a new instance of that motion if (motion && !mPaused && motion->canDeprecate() && motion->isActive() // singu: do not deprecate motions that are not active. && motion->getFadeWeight() > 0.01f // not LOD-ed out && (motion->isBlending() || motion->getStopTime() != 0.f)) { deprecateMotionInstance(motion); // force creation of new instance motion = NULL; } // create new motion instance if (!motion) { motion = createMotion(id); } if (!motion) { return FALSE; } //if the motion is already active and allows deprecation, then let it keep playing else if (motion->canDeprecate() && isMotionActive(motion)) { return TRUE; } // llinfos << "Starting motion " << name << llendl; //<singu> F32 start_time = mAnimTime - start_offset; if (!mDisableSyncing) { start_time = motion->syncActivationTime(start_time); } ++mDisableSyncing; //</singu> BOOL res = activateMotionInstance(motion, start_time); //<singu> --mDisableSyncing; //</singu> return res; }
//----------------------------------------------------------------------------- // removeMotion() //----------------------------------------------------------------------------- void LLMotionController::removeMotion( const LLUUID& id) { LLMotion* motionp = findMotion(id); if (motionp) { stopMotionLocally(id, TRUE); mLoadingMotions.erase(motionp); mLoadedMotions.remove(motionp); mActiveMotions.remove(motionp); mAllMotions.erase(id); delete motionp; } }
//----------------------------------------------------------------------------- // createMotion() //----------------------------------------------------------------------------- LLMotion* LLMotionController::createMotion( const LLUUID &id ) { LLMemType mt(LLMemType::MTYPE_ANIMATION); // do we have an instance of this motion for this character? LLMotion *motion = findMotion(id); // if not, we need to create one if (!motion) { // look up constructor and create it motion = sRegistry.createMotion(id); if (!motion) { return NULL; } // look up name for default motions const char* motion_name = gAnimLibrary.animStateToString(id); if (motion_name) { motion->setName(motion_name); } // initialize the new instance LLMotion::LLMotionInitStatus stat = motion->onInitialize(mCharacter); switch(stat) { case LLMotion::STATUS_FAILURE: llinfos << "Motion " << id << " init failed." << llendl; sRegistry.markBad(id); delete motion; return NULL; case LLMotion::STATUS_HOLD: mLoadingMotions.insert(motion); break; case LLMotion::STATUS_SUCCESS: // add motion to our list mLoadedMotions.insert(motion); break; default: llerrs << "Invalid initialization status" << llendl; break; } mAllMotions[id] = motion; } return motion; }
//----------------------------------------------------------------------------- // stopMotionLocally() //----------------------------------------------------------------------------- BOOL LLMotionController::stopMotionLocally(const LLUUID &id, BOOL stop_immediate) { // if already inactive, return false LLMotion *motion = findMotion(id); return stopMotionInstance(motion, stop_immediate); }
//----------------------------------------------------------------------------- // removeMotion() //----------------------------------------------------------------------------- void LLMotionController::removeMotion( const LLUUID& id) { LLMotion* motionp = findMotion(id); mAllMotions.erase(id); removeMotionInstance(motionp); }