DRTVWR-559 Optimization pass on probe allocation and search. Incidental decruft.

7 files changed, 308 insertions, 123 deletions

diff --git a/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl b/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl
index 9b42f0df5c..bc631afd1d 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl
@@ -47,7 +47,11 @@ layout (std140) uniform ReflectionProbes
     mat4 refBox[MAX_REFMAP_COUNT];
     // list of bounding spheres for reflection probes sorted by distance to camera (closest first)
     vec4 refSphere[MAX_REFMAP_COUNT];
-    // extra parameters (currently only .x used for probe ambiance)
+    // extra parameters 
+    //  x - irradiance scale
+    //  y - radiance scale
+    //  z - fade in
+    //  w - znear
     vec4 refParams[MAX_REFMAP_COUNT];
     // index  of cube map in reflectionProbes for a corresponding reflection probe
     // e.g. cube map channel of refSphere[2] is stored in refIndex[2]
@@ -60,6 +64,8 @@ layout (std140) uniform ReflectionProbes
     // neighbor list data (refSphere indices, not cubemap array layer)
     ivec4 refNeighbor[1024];
 
+    ivec4 refBucket[256];
+
     // number of reflection probes present in refSphere
     int refmapCount;
 };
@@ -118,13 +124,26 @@ bool shouldSampleProbe(int i, vec3 pos)
     return true;
 }
 
+int getStartIndex(vec3 pos)
+{
+#if 1
+    int idx = clamp(int(floor(-pos.z)), 0, 255);
+    return clamp(refBucket[idx].x, 1, refmapCount+1);
+#else
+    return 1;
+#endif
+}
+
 // call before sampleRef
 // populate "probeIndex" with N probe indices that influence pos where N is REF_SAMPLE_COUNT
 void preProbeSample(vec3 pos)
 {
 #if REFMAP_LEVEL > 0
+
+    int start = getStartIndex(pos);
+
     // TODO: make some sort of structure that reduces the number of distance checks
-    for (int i = 1; i < refmapCount; ++i)
+    for (int i = start; i < refmapCount; ++i)
     {
         // found an influencing probe
         if (shouldSampleProbe(i, pos))
@@ -142,6 +161,7 @@ void preProbeSample(vec3 pos)
                 {
                     // check up to REF_SAMPLE_COUNT-1 neighbors (neighborIdx is ivec4 index)
 
+                    // sample refNeighbor[neighborIdx].x
                     int idx = refNeighbor[neighborIdx].x;
                     if (shouldSampleProbe(idx, pos))
                     {
@@ -157,6 +177,7 @@ void preProbeSample(vec3 pos)
                         break;
                     }
 
+                    // sample refNeighbor[neighborIdx].y
                     idx = refNeighbor[neighborIdx].y;
                     if (shouldSampleProbe(idx, pos))
                     {
@@ -172,6 +193,7 @@ void preProbeSample(vec3 pos)
                         break;
                     }
 
+                    // sample refNeighbor[neighborIdx].z
                     idx = refNeighbor[neighborIdx].z;
                     if (shouldSampleProbe(idx, pos))
                     {
@@ -187,6 +209,7 @@ void preProbeSample(vec3 pos)
                         break;
                     }
 
+                    // sample refNeighbor[neighborIdx].w
                     idx = refNeighbor[neighborIdx].w;
                     if (shouldSampleProbe(idx, pos))
                     {
@@ -197,11 +220,7 @@ void preProbeSample(vec3 pos)
                         }
                     }
                     count++;
-                    if (count == neighborCount)
-                    {
-                        break;
-                    }
-
+                    
                     ++neighborIdx;
                 }
 
@@ -735,6 +754,14 @@ vec4 sampleReflectionProbesDebug(vec3 pos)
         debugTapRefMap(pos, dir, d, i, col);
     }
 
+#if 0 //debug getStartIndex
+    col.g = float(getStartIndex(pos));
+
+    col.g /= 255.0;
+    col.rb = vec2(0);
+    col.a = 1.0;
+#endif
+
     return col;
 }
 
diff --git a/indra/newview/llreflectionmap.h b/indra/newview/llreflectionmap.h
index 803f7bdc97..7ea0fe6187 100644
--- a/indra/newview/llreflectionmap.h
+++ b/indra/newview/llreflectionmap.h
@@ -78,8 +78,12 @@ public:
     // point at which environment map was last generated from (in agent space)
     LLVector4a mOrigin;
     
-    // distance from viewer camera
-    F32 mDistance;
+    // distance from main viewer camera
+    F32 mDistance = -1.f;
+
+    // Minimum and maximum depth in current render camera
+    F32 mMinDepth = -1.f;
+    F32 mMaxDepth = -1.f;
 
     // radius of this probe's affected area
     F32 mRadius = 16.f;
diff --git a/indra/newview/llreflectionmapmanager.cpp b/indra/newview/llreflectionmapmanager.cpp
index 88edbc9224..2235453e47 100644
--- a/indra/newview/llreflectionmapmanager.cpp
+++ b/indra/newview/llreflectionmapmanager.cpp
@@ -45,10 +45,13 @@ extern U32 nhpo2(U32 v);
 
 static void touch_default_probe(LLReflectionMap* probe)
 {
-    LLVector3 origin = LLViewerCamera::getInstance()->getOrigin();
-    origin.mV[2] += 64.f;
+    if (LLViewerCamera::getInstance())
+    {
+        LLVector3 origin = LLViewerCamera::getInstance()->getOrigin();
+        origin.mV[2] += 64.f;
 
-    probe->mOrigin.load3(origin.mV);
+        probe->mOrigin.load3(origin.mV);
+    }
 }
 
 LLReflectionMapManager::LLReflectionMapManager()
@@ -58,17 +61,17 @@ LLReflectionMapManager::LLReflectionMapManager()
 
 void LLReflectionMapManager::initCubeFree()
 {
+    // start at 1 because index 0 is reserved for mDefaultProbe
     for (int i = 1; i < LL_MAX_REFLECTION_PROBE_COUNT; ++i)
     {
-        mCubeFree[i] = true;
+        mCubeFree.push_back(i);
     }
-
-    // cube index 0 is reserved for the fallback probe
-    mCubeFree[0] = false;
 }
 
 struct CompareProbeDistance
 {
+    LLReflectionMap* mDefaultProbe;
+
     bool operator()(const LLPointer<LLReflectionMap>& lhs, const LLPointer<LLReflectionMap>& rhs)
     {
         return lhs->mDistance < rhs->mDistance;
@@ -83,7 +86,15 @@ static F32 update_score(LLReflectionMap* p)
 // return true if a is higher priority for an update than b
 static bool check_priority(LLReflectionMap* a, LLReflectionMap* b)
 {
-    if (!a->mComplete && !b->mComplete)
+    if (a->mCubeIndex == -1)
+    { // not a candidate for updating
+        return false;
+    }
+    else if (b->mCubeIndex == -1)
+    { // certainly higher priority than b
+        return true;
+    }
+    else if (!a->mComplete && !b->mComplete)
     { //neither probe is complete, use distance
         return a->mDistance < b->mDistance;
     }
@@ -133,14 +144,7 @@ void LLReflectionMapManager::update()
         }
     }
 
-
-    if (mDefaultProbe.isNull())
-    {
-        mDefaultProbe = addProbe();
-        mDefaultProbe->mDistance = -4096.f; // hack to make sure the default probe is always first in sort order
-        mDefaultProbe->mRadius = 4096.f;
-        touch_default_probe(mDefaultProbe);
-    }
+    llassert(mProbes[0] == mDefaultProbe);
     
     LLVector4a camera_pos;
     camera_pos.load3(LLViewerCamera::instance().getOrigin().mV);
@@ -170,6 +174,7 @@ void LLReflectionMapManager::update()
         return;
     }
 
+
     bool did_update = false;
     
     static LLCachedControl<S32> sDetail(gSavedSettings, "RenderReflectionProbeDetail", -1);
@@ -188,7 +193,46 @@ void LLReflectionMapManager::update()
         doProbeUpdate();
     }
 
-    //LL_INFOS() << mProbes.size() << LL_ENDL;
+    // update distance to camera for all probes
+    std::sort(mProbes.begin()+1, mProbes.end(), CompareProbeDistance());
+    llassert(mProbes[0] == mDefaultProbe);
+    llassert(mProbes[0]->mCubeArray == mTexture);
+    llassert(mProbes[0]->mCubeIndex == 0);
+
+    // make sure we're assigning cube slots to the closest probes
+
+    // first free any cube indices for distant probes
+    for (U32 i = mReflectionProbeCount; i < mProbes.size(); ++i)
+    {
+        LLReflectionMap* probe = mProbes[i];
+        llassert(probe != nullptr);
+
+        if (probe->mCubeIndex != -1 && mUpdatingProbe != probe)
+        { // free this index
+            mCubeFree.push_back(probe->mCubeIndex);
+
+            probe->mCubeArray = nullptr;
+            probe->mCubeIndex = -1;
+            probe->mComplete = false;
+        }
+    }
+
+    // next distribute the free indices
+    U32 count = llmin(mReflectionProbeCount, (U32)mProbes.size());
+
+    for (S32 i = 1; i < count && !mCubeFree.empty(); ++i)
+    {
+        // find the closest probe that needs a cube index
+        LLReflectionMap* probe = mProbes[i];
+
+        if (probe->mCubeIndex == -1)
+        {
+            S32 idx = allocateCubeIndex();
+            llassert(idx > 0); //if we're still in this loop, mCubeFree should not be empty and allocateCubeIndex should be returning good indices
+            probe->mCubeArray = mTexture;
+            probe->mCubeIndex = idx;
+        }
+    }
 
     for (int i = 0; i < mProbes.size(); ++i)
     {
@@ -205,8 +249,6 @@ void LLReflectionMapManager::update()
             continue;
         }
 
-        probe->mProbeIndex = i;
-
         LLVector4a d;
 
         if (probe != mDefaultProbe)
@@ -219,6 +261,10 @@ void LLReflectionMapManager::update()
             // make default probe have a distance of 64m for the purposes of prioritization (if it's already been generated once)
             probe->mDistance = 64.f;
         }
+        else
+        {
+            probe->mDistance = -4096.f; //boost priority of default probe when it's not complete
+        }
 
         if (probe->mComplete)
         {
@@ -288,13 +334,8 @@ void LLReflectionMapManager::update()
     if (!did_update && oldestProbe != nullptr)
     {
         LLReflectionMap* probe = oldestProbe;
-        if (probe->mCubeIndex == -1)
-        {
-            probe->mCubeArray = mTexture;
-
-            probe->mCubeIndex = probe == mDefaultProbe ? 0 : allocateCubeIndex();
-        }
-
+        llassert(probe->mCubeIndex != -1);
+        
         probe->autoAdjustOrigin();
 
         mUpdatingProbe = probe;
@@ -307,10 +348,6 @@ void LLReflectionMapManager::update()
         oldestOccluded->autoAdjustOrigin();
         oldestOccluded->mLastUpdateTime = gFrameTimeSeconds;
     }
-
-    // update distance to camera for all probes
-    mDefaultProbe->mDistance = -4096.f; // make default probe always end up at index 0
-    std::sort(mProbes.begin(), mProbes.end(), CompareProbeDistance());
 }
 
 LLReflectionMap* LLReflectionMapManager::addProbe(LLSpatialGroup* group)
@@ -318,6 +355,14 @@ LLReflectionMap* LLReflectionMapManager::addProbe(LLSpatialGroup* group)
     LLReflectionMap* probe = new LLReflectionMap();
     probe->mGroup = group;
 
+    if (mDefaultProbe.isNull())
+    {  //safety check to make sure default probe is always first probe added
+        mDefaultProbe = new LLReflectionMap();
+        mProbes.push_back(mDefaultProbe);
+    }
+
+    llassert(mProbes[0] == mDefaultProbe);
+
     if (group)
     {
         probe->mOrigin = group->getOctreeNode()->getCenter();
@@ -335,10 +380,22 @@ LLReflectionMap* LLReflectionMapManager::addProbe(LLSpatialGroup* group)
     return probe;
 }
 
+struct CompareProbeDepth
+{
+    bool operator()(const LLReflectionMap* lhs, const LLReflectionMap* rhs)
+    {
+        return lhs->mMinDepth < rhs->mMinDepth;
+    }
+};
+
 void LLReflectionMapManager::getReflectionMaps(std::vector<LLReflectionMap*>& maps)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DISPLAY;
 
+    LLMatrix4a modelview;
+    modelview.loadu(gGLModelView);
+    LLVector4a oa; // scratch space for transformed origin
+
     U32 count = 0;
     U32 lastIdx = 0;
     for (U32 i = 0; count < maps.size() && i < mProbes.size(); ++i)
@@ -348,8 +405,10 @@ void LLReflectionMapManager::getReflectionMaps(std::vector<LLReflectionMap*>& ma
         {
             if (!mProbes[i]->mOccluded && mProbes[i]->mComplete)
             {
-                mProbes[i]->mProbeIndex = count;
                 maps[count++] = mProbes[i];
+                modelview.affineTransform(mProbes[i]->mOrigin, oa);
+                mProbes[i]->mMinDepth = -oa.getF32ptr()[2] - mProbes[i]->mRadius;
+                mProbes[i]->mMaxDepth = -oa.getF32ptr()[2] + mProbes[i]->mRadius;
             }
         }
         else
@@ -365,6 +424,16 @@ void LLReflectionMapManager::getReflectionMaps(std::vector<LLReflectionMap*>& ma
         mProbes[i]->mProbeIndex = -1;
     }
 
+    if (count > 1)
+    {
+        std::sort(maps.begin(), maps.begin() + count, CompareProbeDepth());
+    }
+
+    for (U32 i = 0; i < count; ++i)
+    {
+        maps[i]->mProbeIndex = i;
+    }
+
     // null terminate list
     if (count < maps.size())
     {
@@ -407,32 +476,15 @@ LLReflectionMap* LLReflectionMapManager::registerViewerObject(LLViewerObject* vo
     return probe;
 }
 
-
 S32 LLReflectionMapManager::allocateCubeIndex()
 {
-    for (int i = 0; i < mReflectionProbeCount; ++i)
+    if (!mCubeFree.empty())
     {
-        if (mCubeFree[i])
-        {
-            mCubeFree[i] = false;
-            return i;
-        }
+        S32 ret = mCubeFree.front();
+        mCubeFree.pop_front();
+        return ret;
     }
 
-    // no cubemaps free, steal one from the back of the probe list
-    for (int i = mProbes.size() - 1; i >= mReflectionProbeCount; --i)
-    {
-        if (mProbes[i]->mCubeIndex != -1)
-        {
-            S32 ret = mProbes[i]->mCubeIndex;
-            mProbes[i]->mCubeIndex = -1;
-            mProbes[i]->mCubeArray = nullptr;
-            mProbes[i]->mComplete = false;
-            return ret;
-        }
-    }
-
-    llassert(false); // should never fail to allocate, something is probably wrong with mCubeFree
     return -1;
 }
 
@@ -445,7 +497,7 @@ void LLReflectionMapManager::deleteProbe(U32 i)
 
     if (probe->mCubeIndex != -1)
     { // mark the cube index used by this probe as being free
-        mCubeFree[probe->mCubeIndex] = true;
+        mCubeFree.push_back(probe->mCubeIndex);
     }
     if (mUpdatingProbe == probe)
     {
@@ -776,13 +828,14 @@ void LLReflectionMapManager::updateNeighbors(LLReflectionMap* probe)
     }
 
     // search for new neighbors
+    if (probe->isRelevant())
     {
         LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("rmmun - search");
         for (auto& other : mProbes)
         {
             if (other != mDefaultProbe && other != probe)
             {
-                if (probe->intersects(other))
+                if (other->isRelevant() && probe->intersects(other))
                 {
                     probe->mNeighbors.push_back(other);
                     other->mNeighbors.push_back(probe);
@@ -816,6 +869,7 @@ void LLReflectionMapManager::updateUniforms()
         //  x - irradiance scale
         //  y - radiance scale
         //  z - fade in
+        //  w - znear
         LLVector4 refParams[LL_MAX_REFLECTION_PROBE_COUNT];
 
         // indices used by probe:
@@ -828,6 +882,7 @@ void LLReflectionMapManager::updateUniforms()
         // list of neighbor indices
         GLint refNeighbor[4096]; 
 
+        GLint refBucket[256][4]; //lookup table for which index to start with for the given Z depth
         // numbrer of active refmaps
         GLint refmapCount;  
     };
@@ -837,6 +892,17 @@ void LLReflectionMapManager::updateUniforms()
 
     ReflectionProbeData rpd;
 
+    F32 minDepth[256];
+
+    for (int i = 0; i < 256; ++i)
+    {
+        rpd.refBucket[i][0] = mReflectionProbeCount;
+        rpd.refBucket[i][1] = mReflectionProbeCount;
+        rpd.refBucket[i][2] = mReflectionProbeCount;
+        rpd.refBucket[i][3] = mReflectionProbeCount;
+        minDepth[i] = FLT_MAX;
+    }
+
     // load modelview matrix into matrix 4a
     LLMatrix4a modelview;
     modelview.loadu(gGLModelView);
@@ -861,6 +927,28 @@ void LLReflectionMapManager::updateUniforms()
             break;
         }
 
+        if (refmap != mDefaultProbe)
+        {
+            // bucket search data
+            // theory of operation:
+            //      1. Determine minimum and maximum depth of each influence volume and store in mDepth (done in getReflectionMaps)
+            //      2. Sort by minimum depth
+            //      3. Prepare a bucket for each 1m of depth out to 256m
+            //      4. For each bucket, store the index of the nearest probe that might influence pixels in that bucket
+            //      5. In the shader, lookup the bucket for the pixel depth to get the index of the first probe that could possibly influence
+            //          the current pixel.
+            int depth_min = llclamp(llfloor(refmap->mMinDepth), 0, 255);
+            int depth_max = llclamp(llfloor(refmap->mMaxDepth), 0, 255);
+            for (U32 i = depth_min; i <= depth_max; ++i)
+            {
+                if (refmap->mMinDepth < minDepth[i])
+                {
+                    minDepth[i] = refmap->mMinDepth;
+                    rpd.refBucket[i][0] = refmap->mProbeIndex;
+                }
+            }
+        }
+
         llassert(refmap->mProbeIndex == count);
         llassert(mReflectionMaps[refmap->mProbeIndex] == refmap);
 
@@ -890,7 +978,11 @@ void LLReflectionMapManager::updateUniforms()
             rpd.refIndex[count][3] = -rpd.refIndex[count][3];
         }
 
-        rpd.refParams[count].set(llmax(minimum_ambiance, refmap->getAmbiance())*ambscale, radscale, refmap->mFadeIn, 0.f);
+        rpd.refParams[count].set(
+            llmax(minimum_ambiance, refmap->getAmbiance())*ambscale, // ambiance scale
+            radscale, // radiance scale
+            refmap->mFadeIn, // fade in weight
+            oa.getF32ptr()[2] - refmap->mRadius); // z near
 
         S32 ni = nc; // neighbor ("index") - index into refNeighbor to write indices for current reflection probe's neighbors
         {
@@ -907,7 +999,7 @@ void LLReflectionMapManager::updateUniforms()
                 }
 
                 GLint idx = neighbor->mProbeIndex;
-                if (idx == -1 || neighbor->mOccluded)
+                if (idx == -1 || neighbor->mOccluded || neighbor->mCubeIndex == -1)
                 {
                     continue;
                 }
@@ -944,6 +1036,30 @@ void LLReflectionMapManager::updateUniforms()
         count++;
     }
 
+#if 0
+    {
+        // fill in gaps in refBucket
+        S32 probe_idx = mReflectionProbeCount;
+        
+        for (int i = 0; i < 256; ++i)
+        {
+            if (i < count)
+            { // for debugging, store depth of mReflectionsMaps[i]
+                rpd.refBucket[i][1] = (S32) (mReflectionMaps[i]->mDepth * 10);
+            }
+
+            if (rpd.refBucket[i][0] == mReflectionProbeCount)
+            {
+                rpd.refBucket[i][0] = probe_idx;
+            }
+            else
+            {
+                probe_idx = rpd.refBucket[i][0];
+            }
+        }
+    }
+#endif
+
     rpd.refmapCount = count;
 
     //copy rpd into uniform buffer object
@@ -958,6 +1074,21 @@ void LLReflectionMapManager::updateUniforms()
         glBufferData(GL_UNIFORM_BUFFER, sizeof(ReflectionProbeData), &rpd, GL_STREAM_DRAW);
         glBindBuffer(GL_UNIFORM_BUFFER, 0);
     }
+
+#if 0
+    if (!gCubeSnapshot)
+    {
+        for (auto& probe : mProbes)
+        {
+            LLViewerObject* vobj = probe->mViewerObject;
+            if (vobj)
+            {
+                F32 time = (F32)gFrameTimeSeconds - probe->mLastUpdateTime;
+                vobj->setDebugText(llformat("%d/%d/%d/%.1f - %.1f/%.1f", probe->mCubeIndex, probe->mProbeIndex, (U32) probe->mNeighbors.size(), probe->mMinDepth, probe->mMaxDepth, time), time > 1.f ? LLColor4::white : LLColor4::green);
+            }
+        }
+    }
+#endif
 }
 
 void LLReflectionMapManager::setUniforms()
@@ -977,37 +1108,40 @@ void LLReflectionMapManager::setUniforms()
 
 void renderReflectionProbe(LLReflectionMap* probe)
 {
-    F32* po = probe->mOrigin.getF32ptr();
-
-    //draw orange line from probe to neighbors
-    gGL.flush();
-    gGL.diffuseColor4f(1, 0.5f, 0, 1);
-    gGL.begin(gGL.LINES);
-    for (auto& neighbor : probe->mNeighbors)
+    if (probe->isRelevant())
     {
-        if (probe->mViewerObject && neighbor->mViewerObject)
-        {
-            continue;
-        }
-        
-        gGL.vertex3fv(po);
-        gGL.vertex3fv(neighbor->mOrigin.getF32ptr());
-    }
-    gGL.end();
-    gGL.flush();
+        F32* po = probe->mOrigin.getF32ptr();
 
-    gGL.diffuseColor4f(1, 1, 0, 1);
-    gGL.begin(gGL.LINES);
-    for (auto& neighbor : probe->mNeighbors)
-    {
-        if (probe->mViewerObject && neighbor->mViewerObject)
+        //draw orange line from probe to neighbors
+        gGL.flush();
+        gGL.diffuseColor4f(1, 0.5f, 0, 1);
+        gGL.begin(gGL.LINES);
+        for (auto& neighbor : probe->mNeighbors)
         {
+            if (probe->mViewerObject && neighbor->mViewerObject)
+            {
+                continue;
+            }
+
             gGL.vertex3fv(po);
             gGL.vertex3fv(neighbor->mOrigin.getF32ptr());
         }
+        gGL.end();
+        gGL.flush();
+
+        gGL.diffuseColor4f(1, 1, 0, 1);
+        gGL.begin(gGL.LINES);
+        for (auto& neighbor : probe->mNeighbors)
+        {
+            if (probe->mViewerObject && neighbor->mViewerObject)
+            {
+                gGL.vertex3fv(po);
+                gGL.vertex3fv(neighbor->mOrigin.getF32ptr());
+            }
+        }
+        gGL.end();
+        gGL.flush();
     }
-    gGL.end();
-    gGL.flush();
 
 #if 0
     LLSpatialGroup* group = probe->mGroup;
@@ -1095,7 +1229,6 @@ void LLReflectionMapManager::initReflectionMaps()
         mUpdatingProbe = nullptr;
         mRadiancePass = false;
         mRealtimeRadiancePass = false;
-        mDefaultProbe = nullptr;
 
         for (auto& probe : mProbes)
         {
@@ -1104,14 +1237,28 @@ void LLReflectionMapManager::initReflectionMaps()
             probe->mProbeIndex = -1;
             probe->mCubeArray = nullptr;
             probe->mCubeIndex = -1;
+            probe->mNeighbors.clear();
         }
 
-        for (bool& is_free : mCubeFree)
+        mCubeFree.clear();
+        initCubeFree();
+
+        if (mDefaultProbe.isNull())
         {
-            is_free = true;
+            llassert(mProbes.empty()); // default probe MUST be the first probe created
+            mDefaultProbe = new LLReflectionMap();
+            mProbes.push_back(mDefaultProbe);
         }
 
-        mCubeFree[0] = false;
+        llassert(mProbes[0] == mDefaultProbe);
+
+        mDefaultProbe->mCubeIndex = 0;
+        mDefaultProbe->mCubeArray = mTexture;
+        mDefaultProbe->mDistance = 64.f;
+        mDefaultProbe->mRadius = 4096.f;
+        mDefaultProbe->mProbeIndex = 0;
+        touch_default_probe(mDefaultProbe);
+
     }
 
     if (mVertexBuffer.isNull())
diff --git a/indra/newview/llreflectionmapmanager.h b/indra/newview/llreflectionmapmanager.h
index 234bde51a8..c0618de410 100644
--- a/indra/newview/llreflectionmapmanager.h
+++ b/indra/newview/llreflectionmapmanager.h
@@ -110,7 +110,7 @@ private:
     void deleteProbe(U32 i);
 
     // get a free cube index
-    // if no cube indices are free, free one starting from the back of the probe list
+    // returns -1 if allocation failed
     S32 allocateCubeIndex();
 
     // update the neighbors of the given probe 
@@ -137,12 +137,9 @@ private:
     // storage for reflection probe irradiance maps
     LLPointer<LLCubeMapArray> mIrradianceMaps;
 
-    // array indicating if a particular cubemap is free
-    bool mCubeFree[LL_MAX_REFLECTION_PROBE_COUNT];
+    // list of free cubemap indices
+    std::list<S32> mCubeFree;
 
-    // start tracking the given spatial group
-    void trackGroup(LLSpatialGroup* group);
-    
     // perform an update on the currently updating Probe
     void doProbeUpdate();
 
diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp
index 100c73377f..2f4274d0d0 100644
--- a/indra/newview/llviewerobject.cpp
+++ b/indra/newview/llviewerobject.cpp
@@ -5689,7 +5689,7 @@ S32 LLViewerObject::countInventoryContents(LLAssetType::EType type)
 	return count;
 }
 
-void LLViewerObject::setDebugText(const std::string &utf8text)
+void LLViewerObject::setDebugText(const std::string &utf8text, const LLColor4& color)
 {
 	if (utf8text.empty() && !mText)
 	{
@@ -5700,7 +5700,7 @@ void LLViewerObject::setDebugText(const std::string &utf8text)
 	{
 	    initHudText();
 	}
-	mText->setColor(LLColor4::white);
+	mText->setColor(color);
 	mText->setString(utf8text);
 	mText->setZCompare(FALSE);
 	mText->setDoFade(FALSE);
diff --git a/indra/newview/llviewerobject.h b/indra/newview/llviewerobject.h
index e647fdd045..fe27227e6b 100644
--- a/indra/newview/llviewerobject.h
+++ b/indra/newview/llviewerobject.h
@@ -441,7 +441,7 @@ public:
 
 	void sendMaterialUpdate() const;
 
-	void setDebugText(const std::string &utf8text);
+	void setDebugText(const std::string &utf8text, const LLColor4& color = LLColor4::white);
 	void appendDebugText(const std::string &utf8text);
 	void initHudText();
 	void restoreHudText();
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 126924220c..4bb93d675e 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -6912,7 +6912,8 @@ void LLPipeline::bindScreenToTexture()
 
 static LLTrace::BlockTimerStatHandle FTM_RENDER_BLOOM("Bloom");
 
-void LLPipeline::visualizeBuffers(LLRenderTarget* src, LLRenderTarget* dst, U32 bufferIndex) {
+void LLPipeline::visualizeBuffers(LLRenderTarget* src, LLRenderTarget* dst, U32 bufferIndex)
+{
 	dst->bindTarget();
 	gDeferredBufferVisualProgram.bind();
 	gDeferredBufferVisualProgram.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src, false, LLTexUnit::TFO_BILINEAR, bufferIndex);
@@ -6929,7 +6930,8 @@ void LLPipeline::visualizeBuffers(LLRenderTarget* src, LLRenderTarget* dst, U32
 	dst->flush();
 }
 
-void LLPipeline::generateLuminance(LLRenderTarget* src, LLRenderTarget* dst) {
+void LLPipeline::generateLuminance(LLRenderTarget* src, LLRenderTarget* dst)
+{
 	// luminance sample and mipmap generation
 	{
 		LL_PROFILE_GPU_ZONE("luminance sample");
@@ -7054,7 +7056,8 @@ void LLPipeline::gammaCorrect(LLRenderTarget* src, LLRenderTarget* dst) {
 	dst->flush();
 }
 
-void LLPipeline::copyScreenSpaceReflections(LLRenderTarget* src, LLRenderTarget* dst) {
+void LLPipeline::copyScreenSpaceReflections(LLRenderTarget* src, LLRenderTarget* dst) 
+{
 
 	if (RenderScreenSpaceReflections && !gCubeSnapshot)
 	{
@@ -7080,7 +7083,8 @@ void LLPipeline::copyScreenSpaceReflections(LLRenderTarget* src, LLRenderTarget*
 	}
 }
 
-void LLPipeline::generateGlow(LLRenderTarget* src) {
+void LLPipeline::generateGlow(LLRenderTarget* src) 
+{
 	if (sRenderGlow)
 	{
 		LL_PROFILE_GPU_ZONE("glow");
@@ -7177,7 +7181,8 @@ void LLPipeline::generateGlow(LLRenderTarget* src) {
 	}
 }
 
-void LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst) {
+void LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst) 
+{
 	{
 		llassert(!gCubeSnapshot);
 		bool multisample = RenderFSAASamples > 1 && mRT->fxaaBuffer.isComplete();
@@ -7257,7 +7262,8 @@ void LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst) {
 	}
 }
 
-void LLPipeline::copyRenderTarget(LLRenderTarget* src, LLRenderTarget* dst) {
+void LLPipeline::copyRenderTarget(LLRenderTarget* src, LLRenderTarget* dst)
+{
 
 	LL_PROFILE_GPU_ZONE("copyRenderTarget");
 	dst->bindTarget();
@@ -7277,7 +7283,8 @@ void LLPipeline::copyRenderTarget(LLRenderTarget* src, LLRenderTarget* dst) {
 	dst->flush();
 }
 
-void LLPipeline::combineGlow(LLRenderTarget* src, LLRenderTarget* dst) {
+void LLPipeline::combineGlow(LLRenderTarget* src, LLRenderTarget* dst)
+{
 	// Go ahead and do our glow combine here in our destination.  We blit this later into the front buffer.
 
 	dst->bindTarget();
@@ -7296,7 +7303,8 @@ void LLPipeline::combineGlow(LLRenderTarget* src, LLRenderTarget* dst) {
 	dst->flush();
 }
 
-void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) {
+void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst)
+{
 	{
 		bool dof_enabled =
 			(RenderDepthOfFieldInEditMode || !LLToolMgr::getInstance()->inBuildMode()) &&
@@ -7462,10 +7470,12 @@ void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) {
 			{ // combine result based on alpha
 				
 				dst->bindTarget();
-				if (RenderFSAASamples > 1 && mRT->fxaaBuffer.isComplete()) {
+				if (RenderFSAASamples > 1 && mRT->fxaaBuffer.isComplete())
+                {
 					glViewport(0, 0, dst->getWidth(), dst->getHeight());
 				}
-				else {
+				else
+                {
 					gGLViewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft;
 					gGLViewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom;
 					gGLViewport[2] = gViewerWindow->getWorldViewRectRaw().getWidth();
@@ -7500,6 +7510,7 @@ void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) {
 
 void LLPipeline::renderFinalize()
 {
+    llassert(!gCubeSnapshot);
     LLVertexBuffer::unbind();
     LLGLState::checkStates();
 
@@ -7520,22 +7531,20 @@ void LLPipeline::renderFinalize()
     gGL.setColorMask(true, true);
     glClearColor(0, 0, 0, 0);
 
-    if (!gCubeSnapshot)
-    {
-		copyScreenSpaceReflections(&mRT->screen, &mSceneMap);
+    
+    copyScreenSpaceReflections(&mRT->screen, &mSceneMap);
 
-		generateLuminance(&mRT->screen, &mLuminanceMap);
+    generateLuminance(&mRT->screen, &mLuminanceMap);
 
-		generateExposure(&mLuminanceMap, &mExposureMap);
+    generateExposure(&mLuminanceMap, &mExposureMap);
 
-		gammaCorrect(&mRT->screen, &mPostMap);
+    gammaCorrect(&mRT->screen, &mPostMap);
 
-        LLVertexBuffer::unbind();
-    }
+    LLVertexBuffer::unbind();
 
-	generateGlow(&mPostMap);
+    generateGlow(&mPostMap);
 
-	combineGlow(&mPostMap, &mRT->screen);
+    combineGlow(&mPostMap, &mRT->screen);
 
 	gGLViewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft;
 	gGLViewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom;
@@ -7547,7 +7556,8 @@ void LLPipeline::renderFinalize()
 
 	applyFXAA(&mPostMap, &mRT->screen);
 	LLRenderTarget* finalBuffer = &mRT->screen;
-	if (RenderBufferVisualization > -1) {
+	if (RenderBufferVisualization > -1)
+    {
 		finalBuffer = &mPostMap;
 		switch (RenderBufferVisualization)
 		{