Second Life viewer sources 1.14.0.0

1 files changed, 181 insertions, 124 deletions

diff --git a/linden/indra/newview/llviewerpartsim.cpp b/linden/indra/newview/llviewerpartsim.cpp
index be2c90f..2658e67 100644
--- a/linden/indra/newview/llviewerpartsim.cpp
+++ b/linden/indra/newview/llviewerpartsim.cpp
@@ -32,6 +32,7 @@
 #include "llviewercontrol.h"
 
 #include "llagent.h"
+#include "llviewercamera.h"
 #include "llviewerobjectlist.h"
 #include "llviewerpartsource.h"
 #include "llviewerregion.h"
@@ -41,7 +42,7 @@
 
 const S32 MAX_PART_COUNT = 4096;
 
-const F32 PART_SIM_BOX_SIDE = 32.f;
+const F32 PART_SIM_BOX_SIDE = 16.f;
 const F32 PART_SIM_BOX_OFFSET = 0.5f*PART_SIM_BOX_SIDE;
 const F32 PART_SIM_BOX_RAD = 0.5f*F_SQRT3*PART_SIM_BOX_SIDE;
 
@@ -52,18 +53,28 @@ S32 LLViewerPartSim::sParticleCount = 0;
 
 U32 LLViewerPart::sNextPartID = 1;
 
+F32 calc_desired_size(LLVector3 pos, LLVector2 scale)
+{
+        F32 desired_size = (pos-gCamera->getOrigin()).magVec();
+        desired_size /= 4;
+        return llclamp(desired_size, scale.magVec()*0.5f, PART_SIM_BOX_SIDE*2);
+}
+
 LLViewerPart::LLViewerPart()
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         mPartSourcep = NULL;
 }
 
 LLViewerPart::~LLViewerPart()
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         mPartSourcep = NULL;
 }
 
 LLViewerPart &LLViewerPart::operator=(const LLViewerPart &part)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         mPartID = part.mPartID;
         mFlags = part.mFlags;
         mMaxAge = part.mMaxAge;
@@ -93,6 +104,7 @@ LLViewerPart &LLViewerPart::operator=(const LLViewerPart &part)
 
 void LLViewerPart::init(LLViewerPartSource *sourcep, LLViewerImage *imagep, LLVPCallback cb)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         mPartID = LLViewerPart::sNextPartID;
         LLViewerPart::sNextPartID++;
         mFlags = 0x00f;
@@ -115,8 +127,13 @@ void LLViewerPart::init(LLViewerPartSource *sourcep, LLViewerImage *imagep, LLVP
 
 LLViewerPartGroup::LLViewerPartGroup(const LLVector3 &center_agent, const F32 box_side)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         mVOPartGroupp = NULL;
+        mUniformParticles = TRUE;
+
         mRegionp = gWorldPointer->getRegionFromPosAgent(center_agent);
+        llassert_always(center_agent.isFinite());
+        
         if (!mRegionp)
         {
                 //llwarns << "No region at position, using agent region!" << llendl;
@@ -125,28 +142,39 @@ LLViewerPartGroup::LLViewerPartGroup(const LLVector3 &center_agent, const F32 bo
         mCenterAgent = center_agent;
         mBoxRadius = F_SQRT3*box_side*0.5f;
 
-        LLVector3 rad_vec(box_side*0.5f, box_side*0.5f, box_side*0.5f);
-        rad_vec += LLVector3(0.001f, 0.001f, 0.001f);
-        mMinObjPos = mCenterAgent - rad_vec;
-        mMaxObjPos = mCenterAgent + rad_vec;
+        mVOPartGroupp = (LLVOPartGroup *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_PART_GROUP, getRegion());
+        mVOPartGroupp->setViewerPartGroup(this);
+        mVOPartGroupp->setPositionAgent(getCenterAgent());
+        F32 scale = box_side * 0.5f;
+        mVOPartGroupp->setScale(LLVector3(scale,scale,scale));
+        gPipeline.addObject(mVOPartGroupp);
+
+        LLSpatialGroup* group = mVOPartGroupp->mDrawable->getSpatialGroup();
+
+        LLVector3 center(group->mOctreeNode->getCenter());
+        LLVector3 size(group->mOctreeNode->getSize());
+        size += LLVector3(0.01f, 0.01f, 0.01f);
+        mMinObjPos = center - size;
+        mMaxObjPos = center + size;
+
+        static U32 id_seed = 0;
+        mID = ++id_seed;
 }
 
 LLViewerPartGroup::~LLViewerPartGroup()
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         cleanup();
-        S32 count = mParticles.count();
-        S32 i;
-
-        for (i = 0; i < count; i++)
-        {
-                mParticles[i].mPartSourcep = NULL;
-        }
-        mParticles.reset();
+        
+        S32 count = (S32) mParticles.size();
+        mParticles.clear();
+        
         LLViewerPartSim::decPartCount(count);
 }
 
 void LLViewerPartGroup::cleanup()
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         if (mVOPartGroupp)
         {
                 if (!mVOPartGroupp->isDead())
@@ -157,8 +185,9 @@ void LLViewerPartGroup::cleanup()
         }
 }
 
-BOOL LLViewerPartGroup::posInGroup(const LLVector3 &pos)
+BOOL LLViewerPartGroup::posInGroup(const LLVector3 &pos, const F32 desired_size)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         if ((pos.mV[VX] < mMinObjPos.mV[VX])
                 || (pos.mV[VY] < mMinObjPos.mV[VY])
                 || (pos.mV[VZ] < mMinObjPos.mV[VZ]))
@@ -173,29 +202,33 @@ BOOL LLViewerPartGroup::posInGroup(const LLVector3 &pos)
                 return FALSE;
         }
 
+        if (desired_size > 0 && 
+                (desired_size < mBoxRadius*0.5f ||
+                desired_size > mBoxRadius*2.f))
+        {
+                return FALSE;
+        }
+
         return TRUE;
 }
 
 
-BOOL LLViewerPartGroup::addPart(LLViewerPart &part)
+BOOL LLViewerPartGroup::addPart(LLViewerPart* part, F32 desired_size)
 {
-        if (!posInGroup(part.mPosAgent) || 
-                (mVOPartGroupp.notNull() && (part.mImagep != mVOPartGroupp->getTEImage(0))))
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
+        BOOL uniform_part = part->mScale.mV[0] == part->mScale.mV[1] && 
+                                        !(part->mFlags & LLPartData::LL_PART_FOLLOW_VELOCITY_MASK);
+
+        if (!posInGroup(part->mPosAgent, desired_size) ||
+                (mUniformParticles && !uniform_part) ||
+                (!mUniformParticles && uniform_part))
         {
                 return FALSE;
         }
 
-        if (!mVOPartGroupp)
-        {
-                mVOPartGroupp = (LLVOPartGroup *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_PART_GROUP, getRegion());
-                mVOPartGroupp->setViewerPartGroup(this);
-                mVOPartGroupp->setPositionAgent(getCenterAgent());
-                mVOPartGroupp->setScale(LLVector3(PART_SIM_BOX_SIDE, PART_SIM_BOX_SIDE, PART_SIM_BOX_SIDE));
-                mVOPartGroupp->setTEImage(0, part.mImagep);
-                gPipeline.addObject(mVOPartGroupp);
-        }
+        gPipeline.markRebuild(mVOPartGroupp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
         
-        mParticles.put(part);
+        mParticles.push_back(part);
         LLViewerPartSim::incPartCount(1);
         return TRUE;
 }
@@ -203,33 +236,29 @@ BOOL LLViewerPartGroup::addPart(LLViewerPart &part)
 
 void LLViewerPartGroup::removePart(const S32 part_num)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         // Remove the entry for the particle we just deleted.
-        LLPointer<LLViewerPartSource> ps = mParticles[mParticles.count() - 1].mPartSourcep;
-
-        mParticles[mParticles.count() - 1].mPartSourcep = NULL;
-        mParticles.remove(part_num);
-        if (part_num < mParticles.count())
+        mParticles.erase(mParticles.begin() + part_num);
+        if (mVOPartGroupp.notNull())
         {
-                mParticles[part_num].mPartSourcep = ps;
+                gPipeline.markRebuild(mVOPartGroupp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
         }
-
         LLViewerPartSim::decPartCount(1);
 }
 
-
 void LLViewerPartGroup::updateParticles(const F32 dt)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         S32 i, count;
-
-
+        
         LLVector3 gravity(0.f, 0.f, -9.8f);
 
         LLViewerRegion *regionp = getRegion();
-        count = mParticles.count();
+        count = (S32) mParticles.size();
         for (i = 0; i < count; i++)
         {
                 LLVector3 a(0.f, 0.f, 0.f);
-                LLViewerPart &part = mParticles[i];
+                LLViewerPart& part = *((LLViewerPart*) mParticles[i]);
 
                 // Update current time
                 const F32 cur_time = part.mLastUpdateTime + dt;
@@ -271,8 +300,6 @@ void LLViewerPartGroup::updateParticles(const F32 dt)
 
                         part.mVelocity *= (1.f - step);
                         part.mVelocity += step*delta_pos;
-                        //part.mPosAgent *= 1.f - to_target_frac;
-                        //part.mPosAgent += to_target_frac*part.mPartSourcep->mTargetPosAgent;
                 }
 
 
@@ -341,18 +368,22 @@ void LLViewerPartGroup::updateParticles(const F32 dt)
                         i--;
                         count--;
                 }
-                else if (!posInGroup(part.mPosAgent))
+                else 
                 {
-                        // Transfer particles between groups
-                        gWorldPointer->mPartSim.put(part);
-                        removePart(i);
-                        i--;
-                        count--;
+                        F32 desired_size = calc_desired_size(part.mPosAgent, part.mScale);
+                        if (!posInGroup(part.mPosAgent, desired_size))
+                        {
+                                // Transfer particles between groups
+                                gWorldPointer->mPartSim.put(&part);
+                                removePart(i);
+                                i--;
+                                count--;
+                        }
                 }
         }
 
         // Kill the viewer object if this particle group is empty
-        if (!mParticles.count())
+        if (mParticles.empty())
         {
                 gObjectList.killObject(mVOPartGroupp);
                 mVOPartGroupp = NULL;
@@ -362,15 +393,16 @@ void LLViewerPartGroup::updateParticles(const F32 dt)
 
 void LLViewerPartGroup::shift(const LLVector3 &offset)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         mCenterAgent += offset;
         mMinObjPos += offset;
         mMaxObjPos += offset;
 
-        S32 count = mParticles.count();
+        S32 count = (S32) mParticles.size();
         S32 i;
         for (i = 0; i < count; i++)
         {
-                mParticles[i].mPosAgent += offset;
+                mParticles[i]->mPosAgent += offset;
         }
 }
 
@@ -384,34 +416,34 @@ void LLViewerPartGroup::shift(const LLVector3 &offset)
 
 LLViewerPartSim::LLViewerPartSim()
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         sMaxParticleCount = gSavedSettings.getS32("RenderMaxPartCount");
+        static U32 id_seed = 0;
+        mID = ++id_seed;
 }
 
 
 LLViewerPartSim::~LLViewerPartSim()
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         S32 i;
         S32 count;
 
         // Kill all of the groups (and particles)
-        count = mViewerPartGroups.count();
+        count = (S32) mViewerPartGroups.size();
         for (i = 0; i < count; i++)
         {
                 delete mViewerPartGroups[i];
         }
-        mViewerPartGroups.reset();
+        mViewerPartGroups.clear();
 
         // Kill all of the sources 
-        count = mViewerPartSources.count();
-        for (i = 0; i < count; i++)
-        {
-                mViewerPartSources[i] = NULL;
-        }
-        mViewerPartSources.reset();
+        mViewerPartSources.clear();
 }
 
 BOOL LLViewerPartSim::shouldAddPart()
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         if (sParticleCount > 0.75f*sMaxParticleCount)
         {
 
@@ -432,33 +464,35 @@ BOOL LLViewerPartSim::shouldAddPart()
         return TRUE;
 }
 
-void LLViewerPartSim::addPart(LLViewerPart &part)
+void LLViewerPartSim::addPart(LLViewerPart* part)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         if (sParticleCount < MAX_PART_COUNT)
         {
                 put(part);
         }
 }
 
-LLViewerPartGroup *LLViewerPartSim::put(LLViewerPart &part)
+
+LLViewerPartGroup *LLViewerPartSim::put(LLViewerPart* part)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         const F32 MAX_MAG = 1000000.f*1000000.f; // 1 million
-        if (part.mPosAgent.magVecSquared() > MAX_MAG)
+        if (part->mPosAgent.magVecSquared() > MAX_MAG || !part->mPosAgent.isFinite())
         {
-#ifndef LL_RELEASE_FOR_DOWNLOAD
+#if !LL_RELEASE_FOR_DOWNLOAD
                 llwarns << "LLViewerPartSim::put Part out of range!" << llendl;
-                llwarns << part.mPosAgent << llendl;
+                llwarns << part->mPosAgent << llendl;
 #endif
                 return NULL;
         }
+        
+        F32 desired_size = calc_desired_size(part->mPosAgent, part->mScale);
 
-        S32 i;
-        S32 count;
-
-        count = mViewerPartGroups.count();
-        for (i = 0; i < count; i++)
+        S32 count = (S32) mViewerPartGroups.size();
+        for (S32 i = 0; i < count; i++)
         {
-                if (mViewerPartGroups[i]->addPart(part))
+                if (mViewerPartGroups[i]->addPart(part, desired_size))
                 {
                         // We found a spatial group that we fit into, add us and exit
                         return mViewerPartGroups[i];
@@ -467,43 +501,27 @@ LLViewerPartGroup *LLViewerPartSim::put(LLViewerPart &part)
 
         // Hmm, we didn't fit in any of the existing spatial groups
         // Create a new one...
-        LLViewerPartGroup *groupp = createViewerPartGroup(part.mPosAgent);
+        llassert_always(part->mPosAgent.isFinite());
+        LLViewerPartGroup *groupp = createViewerPartGroup(part->mPosAgent, desired_size);
+        groupp->mUniformParticles = (part->mScale.mV[0] == part->mScale.mV[1] && 
+                                                        !(part->mFlags & LLPartData::LL_PART_FOLLOW_VELOCITY_MASK));
         if (!groupp->addPart(part))
         {
                 llwarns << "LLViewerPartSim::put - Particle didn't go into its box!" << llendl;
                 llinfos << groupp->getCenterAgent() << llendl;
-                llinfos << part.mPosAgent << llendl;
+                llinfos << part->mPosAgent << llendl;
                 return NULL;
         }
         return groupp;
 }
 
-LLViewerPartGroup *LLViewerPartSim::createViewerPartGroup(const LLVector3 &pos_agent)
+LLViewerPartGroup *LLViewerPartSim::createViewerPartGroup(const LLVector3 &pos_agent, const F32 desired_size)
 {
-        F32 x_origin = ((S32)(pos_agent.mV[VX]/PART_SIM_BOX_SIDE))*PART_SIM_BOX_SIDE;
-        if (x_origin > pos_agent.mV[VX])
-        {
-                x_origin -= PART_SIM_BOX_SIDE;
-        }
-
-        F32 y_origin = ((S32)(pos_agent.mV[VY]/PART_SIM_BOX_SIDE))*PART_SIM_BOX_SIDE;
-        if (y_origin > pos_agent.mV[VY])
-        {
-                y_origin -= PART_SIM_BOX_SIDE;
-        }
-
-        F32 z_origin = ((S32)(pos_agent.mV[VZ]/PART_SIM_BOX_SIDE))*PART_SIM_BOX_SIDE;
-        if (z_origin > pos_agent.mV[VZ])
-        {
-                z_origin -= PART_SIM_BOX_SIDE;
-        }
-
-        LLVector3 group_center(x_origin + PART_SIM_BOX_OFFSET,
-                                                        y_origin + PART_SIM_BOX_OFFSET,
-                                                        z_origin + PART_SIM_BOX_OFFSET);
-
-        LLViewerPartGroup *groupp = new LLViewerPartGroup(group_center, PART_SIM_BOX_SIDE);
-        mViewerPartGroups.put(groupp);
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
+        //find a box that has a center position divisible by PART_SIM_BOX_SIDE that encompasses
+        //pos_agent
+        LLViewerPartGroup *groupp = new LLViewerPartGroup(pos_agent, desired_size);
+        mViewerPartGroups.push_back(groupp);
         return groupp;
 }
 
@@ -513,7 +531,7 @@ void LLViewerPartSim::shift(const LLVector3 &offset)
         S32 i;
         S32 count;
 
-        count = mViewerPartSources.count();
+        count = (S32) mViewerPartSources.size();
         for (i = 0; i < count; i++)
         {
                 mViewerPartSources[i]->mPosAgent += offset;
@@ -521,13 +539,20 @@ void LLViewerPartSim::shift(const LLVector3 &offset)
                 mViewerPartSources[i]->mLastUpdatePosAgent += offset;
         }
 
-        count = mViewerPartGroups.count();
+        count = (S32) mViewerPartGroups.size();
         for (i = 0; i < count; i++)
         {
                 mViewerPartGroups[i]->shift(offset);
         }
 }
 
+S32 dist_rate_func(F32 distance)
+{
+        //S32 dist = (S32) sqrtf(distance);
+        //dist /= 2;
+        //return llmax(dist,1);
+        return 1;
+}
 
 void LLViewerPartSim::updateSimulation()
 {
@@ -542,13 +567,15 @@ void LLViewerPartSim::updateSimulation()
                 return;
         }
 
+        LLFastTimer ftm(LLFastTimer::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 = mViewerPartSources.count();
+        S32 count = (S32) mViewerPartSources.size();
         S32 start = (S32)ll_frand((F32)count);
         S32 dir = 1;
         if (ll_frand() > 0.5f)
@@ -570,12 +597,24 @@ void LLViewerPartSim::updateSimulation()
 
                 if (!mViewerPartSources[i]->isDead())
                 {
-                        mViewerPartSources[i]->update(dt);
+                        LLViewerObject* source_object = mViewerPartSources[i]->mSourceObjectp;
+                        if (source_object && source_object->mDrawable.notNull())
+                        {
+                S32 dist = dist_rate_func(source_object->mDrawable->mDistanceWRTCamera);
+                                if ((LLDrawable::getCurrentFrame()+mViewerPartSources[i]->mID)%dist == 0)
+                                {
+                                        mViewerPartSources[i]->update(dt*dist);
+                                }
+                        }
+                        else
+                        {
+                                mViewerPartSources[i]->update(dt);
+                        }
                 }
 
                 if (mViewerPartSources[i]->isDead())
                 {
-                        mViewerPartSources.remove(i);
+                        mViewerPartSources.erase(mViewerPartSources.begin() + i);
                         count--;
                 }
                 else
@@ -586,16 +625,36 @@ void LLViewerPartSim::updateSimulation()
         }
 
 
-        count = mViewerPartGroups.count();
+        count = (S32) mViewerPartGroups.size();
         for (i = 0; i < count; i++)
         {
-                mViewerPartGroups[i]->updateParticles(dt);
-                if (!mViewerPartGroups[i]->getCount())
+                LLViewerObject* vobj = mViewerPartGroups[i]->mVOPartGroupp;
+
+                S32 dist = vobj && !vobj->mDrawable->isState(LLDrawable::IN_REBUILD_Q1) ? 
+                                dist_rate_func(vobj->mDrawable->mDistanceWRTCamera) : 1;
+                if (vobj)
                 {
-                        delete mViewerPartGroups[i];
-                        mViewerPartGroups.remove(i);
-                        i--;
-                        count--;
+                        LLSpatialGroup* group = vobj->mDrawable->getSpatialGroup();
+                        if (group && !group->isVisible()) // && !group->isState(LLSpatialGroup::OBJECT_DIRTY))
+                        {
+                                dist *= 8;
+                        }
+                }
+
+                if ((LLDrawable::getCurrentFrame()+mViewerPartGroups[i]->mID)%dist == 0)
+                {
+                        if (vobj)
+                        {
+                                gPipeline.markRebuild(vobj->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
+                        }
+                        mViewerPartGroups[i]->updateParticles(dt*dist);
+                        if (!mViewerPartGroups[i]->getCount())
+                        {
+                                delete mViewerPartGroups[i];
+                                mViewerPartGroups.erase(mViewerPartGroups.begin() + i);
+                                i--;
+                                count--;
+                        }
                 }
         }
         //llinfos << "Particles: " << sParticleCount << llendl;
@@ -604,42 +663,40 @@ void LLViewerPartSim::updateSimulation()
 
 void LLViewerPartSim::addPartSource(LLViewerPartSource *sourcep)
 {
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
         if (!sourcep)
         {
                 llwarns << "Null part source!" << llendl;
                 return;
         }
-        mViewerPartSources.put(sourcep);
+        mViewerPartSources.push_back(sourcep);
 }
 
 
 void LLViewerPartSim::cleanupRegion(LLViewerRegion *regionp)
 {
-        S32 i, count;
-        count = mViewerPartGroups.count();
-        for (i = 0; i < count; i++)
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
+        for (group_list_t::iterator i = mViewerPartGroups.begin(); i != mViewerPartGroups.end(); )
         {
-                if (mViewerPartGroups[i]->getRegion() == regionp)
+                group_list_t::iterator iter = i++;
+
+                if ((*iter)->getRegion() == regionp)
                 {
-                        delete mViewerPartGroups[i];
-                        mViewerPartGroups.remove(i);
-                        i--;
-                        count--;
+                        i = mViewerPartGroups.erase(iter);                      
                 }
         }
 }
 
 void LLViewerPartSim::cleanMutedParticles(const LLUUID& task_id)
 {
-        S32 i;
-        S32 count = mViewerPartSources.count();
-        for (i = 0; i < count; ++i)
+        LLMemType mt(LLMemType::MTYPE_PARTICLES);
+        for (source_list_t::iterator i = mViewerPartSources.begin(); i != mViewerPartSources.end(); )
         {
-                if (mViewerPartSources[i]->getOwnerUUID() == task_id)
+                source_list_t::iterator iter = i++;
+
+                if ((*iter)->getOwnerUUID() == task_id)
                 {
-                        mViewerPartSources.remove(i);
-                        i--;
-                        count--;
+                        i = mViewerPartSources.erase(iter);                     
                 }
         }
 }