LLVolumeImplFlexible::~LLVolumeImplFlexible()
{
std::vector<LLVolumeImplFlexible*>::iterator flex_it(sInstanceList.begin() + mInstanceIndex);
std::vector<LLVolumeImplFlexible*>::iterator iter = vector_replace_with_last(sInstanceList, flex_it);
if(iter != sInstanceList.end())
(*iter)->mInstanceIndex = mInstanceIndex;
std::vector<U32>::iterator update_it(sUpdateDelay.begin() + mInstanceIndex);
vector_replace_with_last(sUpdateDelay, update_it);
}
// virtual
BOOL LLFacePool::removeFace(LLFace *facep)
{
removeFaceReference(facep);
vector_replace_with_last(mDrawFace, facep);
return TRUE;
}
// Destroys the object
LLInventoryView::~LLInventoryView( void )
{
// Save the filters state.
LLSD filterRoot;
LLInventoryPanel* all_items_panel = getChild<LLInventoryPanel>("All Items");
if (all_items_panel)
{
LLInventoryFilter* filter = all_items_panel->getFilter();
if (filter)
{
LLSD filterState;
filter->toLLSD(filterState);
filterRoot[filter->getName()] = filterState;
}
}
LLInventoryPanel* recent_items_panel = getChild<LLInventoryPanel>("Recent Items");
if (recent_items_panel)
{
LLInventoryFilter* filter = recent_items_panel->getFilter();
if (filter)
{
LLSD filterState;
filter->toLLSD(filterState);
filterRoot[filter->getName()] = filterState;
}
}
LLInventoryPanel* worn_items_panel = getChild<LLInventoryPanel>("Worn Items");
if (worn_items_panel)
{
LLInventoryFilter* filter = worn_items_panel->getFilter();
if (filter)
{
LLSD filterState;
filter->toLLSD(filterState);
filterRoot[filter->getName()] = filterState;
}
}
std::ostringstream filterSaveName;
filterSaveName << gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "filters.xml");
llofstream filtersFile(filterSaveName.str());
if(!LLSDSerialize::toPrettyXML(filterRoot, filtersFile))
{
LL_WARNS() << "Could not write to filters save file " << filterSaveName.str().c_str() << LL_ENDL;
}
else
filtersFile.close();
vector_replace_with_last(sActiveViews, this);
gInventory.removeObserver(this);
delete mSavedFolderState;
}
void LLViewerPartSim::cleanupRegion(LLViewerRegion *regionp)
{
group_list_t& vec = mViewerPartGroups;
for (group_list_t::iterator it = vec.begin();it!=vec.end();)
{
if ((*it)->getRegion() == regionp)
{
delete *it;
it = vector_replace_with_last(vec,it);
//i = mViewerPartGroups.erase(iter);
}
else ++it;
}
}
void LLViewerPartSim::updateSimulation()
{
static LLFrameTimer update_timer;
//reset VBO cursor
const F32 dt = llmin(update_timer.getElapsedTimeAndResetF32(), 0.1f);
if (!(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES)))
{
return;
}
LLFastTimer ftm(FTM_SIMULATE_PARTICLES);
// Start at a random particle system so the same
// particle system doesn't always get first pick at the
// particles. Theoretically we'd want to do this in distance
// order or something, but sorting particle sources will be a big
// pain.
S32 i;
S32 count = (S32) mViewerPartSources.size();
S32 start = (S32)ll_frand((F32)count);
S32 dir = 1;
if (ll_frand() > 0.5f)
{
dir = -1;
}
S32 num_updates = 0;
for (i = start; num_updates < count;)
{
if (i >= count)
{
i = 0;
}
if (i < 0)
{
i = count - 1;
}
if (!mViewerPartSources[i]->isDead())
{
BOOL upd = TRUE;
//if (!LLPipeline::sRenderAttachedParticles)
{
LLViewerObject* vobj = mViewerPartSources[i]->mSourceObjectp;
if (vobj && (vobj->getPCode() == LL_PCODE_VOLUME))
{
LLVOVolume* vvo = (LLVOVolume *)vobj;
if (vvo && vvo->isAttachment())
{
if (!LLPipeline::sRenderAttachedParticles)
upd = FALSE;
else
{
LLVOAvatar *avatar = vvo->getAvatar();
if(avatar && avatar->isVisuallyMuted())
upd = FALSE;
}
}
}
}
if (upd)
{
mViewerPartSources[i]->update(dt);
}
}
if (mViewerPartSources[i]->isDead())
{
vector_replace_with_last(mViewerPartSources, mViewerPartSources.begin() + i);
//mViewerPartSources.erase(it);
count--;
}
else
{
i += dir;
}
num_updates++;
}
count = (S32) mViewerPartGroups.size();
for (i = 0; i < count; i++)
{
LLViewerObject* vobj = mViewerPartGroups[i]->mVOPartGroupp;
S32 visirate = 1;
if (vobj && vobj->mDrawable.notNull())
{
LLSpatialGroup* group = vobj->mDrawable->getSpatialGroup();
if (group && !group->isVisible()) // && !group->isState(LLSpatialGroup::OBJECT_DIRTY))
{
visirate = 8;
}
}
if ((LLDrawable::getCurrentFrame()+mViewerPartGroups[i]->mID)%visirate == 0)
{
if (vobj && vobj->mDrawable.notNull())
{
gPipeline.markRebuild(vobj->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
}
mViewerPartGroups[i]->updateParticles(dt * visirate);
mViewerPartGroups[i]->mSkippedTime=0.0f;
if (!mViewerPartGroups[i]->getCount())
{
delete mViewerPartGroups[i];
vector_replace_with_last(mViewerPartGroups, mViewerPartGroups.begin() + i);
//mViewerPartGroups.erase(it);
i--;
count--;
}
}
else
{
mViewerPartGroups[i]->mSkippedTime+=dt;
}
}
if (LLDrawable::getCurrentFrame()%16==0)
{
if (sParticleCount > sMaxParticleCount * 0.875f
&& sParticleAdaptiveRate < 2.0f)
{
sParticleAdaptiveRate *= PART_ADAPT_RATE_MULT;
}
else
{
if (sParticleCount < sMaxParticleCount * 0.5f
&& sParticleAdaptiveRate > 0.03125f)
{
sParticleAdaptiveRate *= PART_ADAPT_RATE_MULT_RECIP;
}
}
}
updatePartBurstRate() ;
//llinfos << "Particles: " << sParticleCount << " Adaptive Rate: " << sParticleAdaptiveRate << llendl;
}
void LLViewerPartGroup::updateParticles(const F32 lastdt)
{
F32 dt;
LLVector3 gravity(0.f, 0.f, GRAVITY);
LLViewerPartSim::checkParticleCount(mParticles.size());
LLViewerCamera* camera = LLViewerCamera::getInstance();
LLViewerRegion *regionp = getRegion();
S32 end = (S32) mParticles.size();
for (S32 i = 0 ; i < (S32)mParticles.size();)
{
LLVector3 a(0.f, 0.f, 0.f);
LLViewerPart* part = mParticles[i] ;
dt = lastdt + mSkippedTime - part->mSkipOffset;
part->mSkipOffset = 0.f;
// Update current time
const F32 cur_time = part->mLastUpdateTime + dt;
const F32 frac = cur_time / part->mMaxAge;
// "Drift" the object based on the source object
if (part->mFlags & LLPartData::LL_PART_FOLLOW_SRC_MASK)
{
part->mPosAgent = part->mPartSourcep->mPosAgent;
part->mPosAgent += part->mPosOffset;
}
// Do a custom callback if we have one...
if (part->mVPCallback)
{
(*part->mVPCallback)(*part, dt);
}
if (part->mFlags & LLPartData::LL_PART_WIND_MASK)
{
LLVector3 tempVel(part->mVelocity);
part->mVelocity *= 1.f - 0.1f*dt;
part->mVelocity += 0.1f*dt*regionp->mWind.getVelocity(regionp->getPosRegionFromAgent(part->mPosAgent));
}
// Now do interpolation towards a target
if (part->mFlags & LLPartData::LL_PART_TARGET_POS_MASK)
{
F32 remaining = part->mMaxAge - part->mLastUpdateTime;
F32 step = dt / remaining;
step = llclamp(step, 0.f, 0.1f);
step *= 5.f;
// we want a velocity that will result in reaching the target in the
// Interpolate towards the target.
LLVector3 delta_pos = part->mPartSourcep->mTargetPosAgent - part->mPosAgent;
delta_pos /= remaining;
part->mVelocity *= (1.f - step);
part->mVelocity += step*delta_pos;
}
if (part->mFlags & LLPartData::LL_PART_TARGET_LINEAR_MASK)
{
LLVector3 delta_pos = part->mPartSourcep->mTargetPosAgent - part->mPartSourcep->mPosAgent;
part->mPosAgent = part->mPartSourcep->mPosAgent;
part->mPosAgent += frac*delta_pos;
part->mVelocity = delta_pos;
}
else
{
// Do velocity interpolation
part->mPosAgent += dt*part->mVelocity;
part->mPosAgent += 0.5f*dt*dt*part->mAccel;
part->mVelocity += part->mAccel*dt;
}
// Do a bounce test
if (part->mFlags & LLPartData::LL_PART_BOUNCE_MASK)
{
// Need to do point vs. plane check...
// For now, just check relative to object height...
F32 dz = part->mPosAgent.mV[VZ] - part->mPartSourcep->mPosAgent.mV[VZ];
if (dz < 0)
{
part->mPosAgent.mV[VZ] += -2.f*dz;
part->mVelocity.mV[VZ] *= -0.75f;
}
}
// Reset the offset from the source position
if (part->mFlags & LLPartData::LL_PART_FOLLOW_SRC_MASK)
{
part->mPosOffset = part->mPosAgent;
part->mPosOffset -= part->mPartSourcep->mPosAgent;
}
// Do color interpolation
if (part->mFlags & LLPartData::LL_PART_INTERP_COLOR_MASK)
{
part->mColor.setVec(part->mStartColor);
// note: LLColor4's v%k means multiply-alpha-only,
// LLColor4's v*k means multiply-rgb-only
part->mColor *= 1.f - frac; // rgb*k
part->mColor %= 1.f - frac; // alpha*k
part->mColor += frac%(frac*part->mEndColor); // rgb,alpha
}
// Do scale interpolation
if (part->mFlags & LLPartData::LL_PART_INTERP_SCALE_MASK)
{
part->mScale.setVec(part->mStartScale);
part->mScale *= 1.f - frac;
part->mScale += frac*part->mEndScale;
}
// Do glow interpolation
part->mGlow.mV[3] = (U8) llmath::llround(lerp(part->mStartGlow, part->mEndGlow, frac)*255.f);
// Set the last update time to now.
part->mLastUpdateTime = cur_time;
// Kill dead particles (either flagged dead, or too old)
if ((part->mLastUpdateTime > part->mMaxAge) || (LLViewerPart::LL_PART_DEAD_MASK == part->mFlags))
{
vector_replace_with_last(mParticles, mParticles.begin() + i);
delete part ;
}
else
{
F32 desired_size = calc_desired_size(camera, part->mPosAgent, part->mScale);
if (!posInGroup(part->mPosAgent, desired_size))
{
// Transfer particles between groups
LLViewerPartSim::getInstance()->put(part) ;
vector_replace_with_last(mParticles, mParticles.begin() + i);
}
else
{
i++ ;
}
}
}
S32 removed = end - (S32)mParticles.size();
if (removed > 0)
{
// we removed one or more particles, so flag this group for update
if (mVOPartGroupp.notNull())
{
gPipeline.markRebuild(mVOPartGroupp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
}
LLViewerPartSim::decPartCount(removed);
}
// Kill the viewer object if this particle group is empty
if (mParticles.empty())
{
gObjectList.killObject(mVOPartGroupp);
mVOPartGroupp = NULL;
}
LLViewerPartSim::checkParticleCount() ;
}
