secondlife/viewer#2674 Optimize LLWorld::renderPropertyLines() - use vertexBatchPreTransformed()

5 files changed, 133 insertions, 61 deletions

diff --git a/indra/llmath/v3math.h b/indra/llmath/v3math.h
index 196ecdcf7d..0e11dca876 100644
--- a/indra/llmath/v3math.h
+++ b/indra/llmath/v3math.h
@@ -155,6 +155,7 @@ class LLVector3
         friend const LLVector3& operator*=(LLVector3 &a, const LLVector3 &b);   // Returns a * b;
         friend const LLVector3& operator*=(LLVector3 &a, F32 k);                // Return a times scaler k
         friend const LLVector3& operator/=(LLVector3 &a, F32 k);                // Return a divided by scaler k
+        friend const LLVector3& operator/=(LLVector3& a, const LLVector3& b);
         friend const LLVector3& operator*=(LLVector3 &a, const LLQuaternion &b);    // Returns a * b;
 
         friend LLVector3 operator-(const LLVector3 &a);                 // Return vector -a
@@ -460,6 +461,14 @@ inline const LLVector3& operator/=(LLVector3& a, F32 k)
     return a;
 }
 
+inline const LLVector3& operator/=(LLVector3& a, const LLVector3& b)
+{
+    a.mV[VX] /= b.mV[VX];
+    a.mV[VY] /= b.mV[VY];
+    a.mV[VZ] /= b.mV[VZ];
+    return a;
+}
+
 inline LLVector3 operator-(const LLVector3& a)
 {
     return LLVector3(-a.mV[VX], -a.mV[VY], -a.mV[VZ]);
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index 57be8570af..1a3a499b20 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -1774,25 +1774,64 @@ void LLRender::vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z)
         return;
     }
 
-    if (mUIOffset.empty())
+    LLVector4a vert(x, y, z);
+    transform(vert);
+    mVerticesp[mCount] = vert;
+
+    mCount++;
+    mVerticesp[mCount] = mVerticesp[mCount-1];
+    mColorsp[mCount] = mColorsp[mCount-1];
+    mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
+}
+
+void LLRender::transform(LLVector3& vert)
+{
+    if (!mUIOffset.empty())
     {
-        mVerticesp[mCount].set(x,y,z);
+        vert += LLVector3(mUIOffset.back().getF32ptr());
+        vert *= LLVector3(mUIScale.back().getF32ptr());
     }
-    else
+}
+
+void LLRender::transform(LLVector4a& vert)
+{
+    if (!mUIOffset.empty())
     {
-        LLVector4a vert(x, y, z);
         vert.add(mUIOffset.back());
         vert.mul(mUIScale.back());
-        mVerticesp[mCount] = vert;
     }
+}
 
-    mCount++;
-    mVerticesp[mCount] = mVerticesp[mCount-1];
-    mColorsp[mCount] = mColorsp[mCount-1];
-    mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
+void LLRender::untransform(LLVector3& vert)
+{
+    if (!mUIOffset.empty())
+    {
+        vert /= LLVector3(mUIScale.back().getF32ptr());
+        vert -= LLVector3(mUIOffset.back().getF32ptr());
+    }
+}
+
+void LLRender::batchTransform(LLVector4a* verts, U32 vert_count)
+{
+    if (!mUIOffset.empty())
+    {
+        const LLVector4a& offset = mUIOffset.back();
+        const LLVector4a& scale = mUIScale.back();
+
+        for (U32 i = 0; i < vert_count; ++i)
+        {
+            verts[i].add(offset);
+            verts[i].mul(scale);
+        }
+    }
+}
+
+void LLRender::vertexBatchPreTransformed(const std::vector<LLVector4a>& verts)
+{
+    vertexBatchPreTransformed(verts.data(), narrow(verts.size()));
 }
 
-void LLRender::vertexBatchPreTransformed(LLVector4a* verts, S32 vert_count)
+void LLRender::vertexBatchPreTransformed(const LLVector4a* verts, S32 vert_count)
 {
     if (mCount + vert_count > 4094)
     {
@@ -1813,7 +1852,7 @@ void LLRender::vertexBatchPreTransformed(LLVector4a* verts, S32 vert_count)
         mVerticesp[mCount] = mVerticesp[mCount-1];
 }
 
-void LLRender::vertexBatchPreTransformed(LLVector4a* verts, LLVector2* uvs, S32 vert_count)
+void LLRender::vertexBatchPreTransformed(const LLVector4a* verts, const LLVector2* uvs, S32 vert_count)
 {
     if (mCount + vert_count > 4094)
     {
@@ -1837,7 +1876,7 @@ void LLRender::vertexBatchPreTransformed(LLVector4a* verts, LLVector2* uvs, S32
     }
 }
 
-void LLRender::vertexBatchPreTransformed(LLVector4a* verts, LLVector2* uvs, LLColor4U* colors, S32 vert_count)
+void LLRender::vertexBatchPreTransformed(const LLVector4a* verts, const LLVector2* uvs, const LLColor4U* colors, S32 vert_count)
 {
     if (mCount + vert_count > 4094)
     {
diff --git a/indra/llrender/llrender.h b/indra/llrender/llrender.h
index 0801c12fb4..be8539433c 100644
--- a/indra/llrender/llrender.h
+++ b/indra/llrender/llrender.h
@@ -450,9 +450,16 @@ public:
     void diffuseColor4ubv(const U8* c);
     void diffuseColor4ub(U8 r, U8 g, U8 b, U8 a);
 
-    void vertexBatchPreTransformed(LLVector4a* verts, S32 vert_count);
-    void vertexBatchPreTransformed(LLVector4a* verts, LLVector2* uvs, S32 vert_count);
-    void vertexBatchPreTransformed(LLVector4a* verts, LLVector2* uvs, LLColor4U*, S32 vert_count);
+    void transform(LLVector3& vert);
+    void transform(LLVector4a& vert);
+    void untransform(LLVector3& vert);
+
+    void batchTransform(LLVector4a* verts, U32 vert_count);
+
+    void vertexBatchPreTransformed(const std::vector<LLVector4a>& verts);
+    void vertexBatchPreTransformed(const LLVector4a* verts, S32 vert_count);
+    void vertexBatchPreTransformed(const LLVector4a* verts, const LLVector2* uvs, S32 vert_count);
+    void vertexBatchPreTransformed(const LLVector4a* verts, const LLVector2* uvs, const LLColor4U*, S32 vert_count);
 
     void setColorMask(bool writeColor, bool writeAlpha);
     void setColorMask(bool writeColorR, bool writeColorG, bool writeColorB, bool writeAlpha);
diff --git a/indra/newview/llviewerparceloverlay.cpp b/indra/newview/llviewerparceloverlay.cpp
index 6b4bcbe86e..63bcd82798 100755
--- a/indra/newview/llviewerparceloverlay.cpp
+++ b/indra/newview/llviewerparceloverlay.cpp
@@ -555,52 +555,52 @@ void LLViewerParcelOverlay::addPropertyLine(F32 start_x, F32 start_y, F32 dx, F3
             inside_z = land.resolveHeightRegion(inside_x, inside_y);
         };
 
-    auto split = [&](U32 lod, const LLVector3& start, F32 x, F32 y, F32 z, F32 part)
+    auto split = [&](U32 lod, const LLVector4a& start, F32 x, F32 y, F32 z, F32 part)
         {
-            F32 new_x = start.mV[VX] + (x - start.mV[VX]) * part;
-            F32 new_y = start.mV[VY] + (y - start.mV[VY]) * part;
-            F32 new_z = start.mV[VZ] + (z - start.mV[VZ]) * part;
-            edge.vertices[lod].emplace_back(new_x, new_y, new_z);
+            F32 new_x = start[VX] + (x - start[VX]) * part;
+            F32 new_y = start[VY] + (y - start[VY]) * part;
+            F32 new_z = start[VZ] + (z - start[VZ]) * part;
+            edge.pushVertex(lod, new_x, new_y, new_z, water_z);
         };
 
     auto checkForSplit = [&](U32 lod)
         {
-            const std::vector<LLVector3>& vertices = edge.vertices[lod];
-            const LLVector3& last_outside = vertices.back();
-            F32 z0 = last_outside.mV[VZ];
+            const std::vector<LLVector4a>& vertices = edge.verticesUnderWater[lod];
+            const LLVector4a& last_outside = vertices.back();
+            F32 z0 = last_outside[VZ];
             F32 z1 = outside_z;
             if ((z0 >= water_z && z1 >= water_z) || (z0 < water_z && z1 < water_z))
                 return;
             F32 part = (water_z - z0) / (z1 - z0);
-            const LLVector3& last_inside = vertices[vertices.size() - 2];
+            const LLVector4a& last_inside = vertices[vertices.size() - 2];
             split(lod, last_inside, inside_x, inside_y, inside_z, part);
             split(lod, last_outside, outside_x, outside_y, outside_z, part);
         };
 
     auto pushTwoVertices = [&](U32 lod)
         {
+            LLVector3 out(outside_x, outside_y, outside_z);
+            LLVector3 in(inside_x, inside_y, inside_z);
             if (fabs(inside_z - outside_z) < LINE_WIDTH / 5)
             {
-                edge.vertices[lod].emplace_back(inside_x, inside_y, inside_z);
+                edge.pushVertex(lod, inside_x, inside_y, inside_z, water_z);
             }
             else
             {
                 // Make the line thinner if heights differ too much
-                LLVector3 out(outside_x, outside_y, outside_z);
-                LLVector3 in(inside_x, inside_y, inside_z);
                 LLVector3 dist(in - out);
                 F32 coef = dist.length() / LINE_WIDTH;
                 LLVector3 new_in(out + dist / coef);
-                edge.vertices[lod].push_back(new_in);
+                edge.pushVertex(lod, new_in[VX], new_in[VY], new_in[VZ], water_z);
             }
-            edge.vertices[lod].emplace_back(outside_x, outside_y, outside_z);
+            edge.pushVertex(lod, outside_x, outside_y, outside_z, water_z);
         };
 
     // Point A simplified (first two vertices)
     pushTwoVertices(1);
 
     // Point A detailized (only one vertex)
-    edge.vertices[0].emplace_back(outside_x, outside_y, outside_z);
+    edge.pushVertex(0, outside_x, outside_y, outside_z, water_z);
 
     // Point B (two vertices)
     move(LINE_WIDTH);
@@ -628,7 +628,23 @@ void LLViewerParcelOverlay::addPropertyLine(F32 start_x, F32 start_y, F32 dx, F3
     pushTwoVertices(1);
 
     // Point G detailized (only one vertex)
-    edge.vertices[0].emplace_back(outside_x, outside_y, outside_z);
+    edge.pushVertex(0, outside_x, outside_y, outside_z, water_z);
+}
+
+void LLViewerParcelOverlay::Edge::pushVertex(U32 lod, F32 x, F32 y, F32 z, F32 water_z)
+{
+    verticesUnderWater[lod].emplace_back(x, y, z);
+    gGL.transform(verticesUnderWater[lod].back());
+
+    if (z >= water_z)
+    {
+        verticesAboveWater[lod].push_back(verticesUnderWater[lod].back());
+    }
+    else
+    {
+        verticesAboveWater[lod].emplace_back(x, y, water_z);
+        gGL.transform(verticesAboveWater[lod].back());
+    }
 }
 
 void LLViewerParcelOverlay::setDirty()
@@ -673,6 +689,9 @@ void LLViewerParcelOverlay::renderPropertyLines()
     if (!show)
         return;
 
+    LL_PROFILE_ZONE_SCOPED;
+    LL_PROFILE_GPU_ZONE("Property Lines");
+
     LLSurface& land = mRegion->getLand();
 
     bool render_water = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_WATER);
@@ -710,6 +729,8 @@ void LLViewerParcelOverlay::renderPropertyLines()
 
     // Stomp the camera into two dimensions
     LLVector3 camera_region = mRegion->getPosRegionFromGlobal( gAgentCamera.getCameraPositionGlobal() );
+    bool draw_underwater = camera_region.mV[VZ] < water_z ||
+        !gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_WATER);
 
     // Set up a cull plane 2 * PARCEL_GRID_STEP_METERS behind
     // the camera.  The cull plane normal is the camera's at axis.
@@ -717,17 +738,22 @@ void LLViewerParcelOverlay::renderPropertyLines()
     cull_plane_point *= -2.f * PARCEL_GRID_STEP_METERS;
     cull_plane_point += camera_region;
 
-    bool render_hidden = LLSelectMgr::sRenderHiddenSelections && LLFloaterReg::instanceVisible("build");
+    bool render_hidden = !draw_underwater &&
+        LLSelectMgr::sRenderHiddenSelections &&
+        LLFloaterReg::instanceVisible("build");
 
     constexpr F32 PROPERTY_LINE_CLIP_DIST_SQUARED = 256.f * 256.f;
     const F32 PROPERTY_LINE_LOD0_DIST_SQUARED = PROPERTY_LINE_CLIP_DIST_SQUARED / 25;
 
     for (const Edge& edge : mEdges)
     {
-        const std::vector<LLVector3>& vertices0 = edge.vertices[0];
-        LLVector3 center = (vertices0.front() + vertices0.back()) / 2;
-        F32 dist_squared = dist_vec_squared(center, camera_region);
+        const std::vector<LLVector4a>& vertices0 = edge.verticesAboveWater[0];
+        const F32* first = vertices0.front().getF32ptr();
+        const F32* last = vertices0.back().getF32ptr();
+        LLVector3 center((first[VX] + last[VX]) / 2, (first[VY] + last[VY]) / 2, (first[VZ] + last[VZ]) / 2);
+        gGL.untransform(center);
 
+        F32 dist_squared = dist_vec_squared(center, camera_region);
         if (dist_squared > PROPERTY_LINE_CLIP_DIST_SQUARED)
         {
             continue;
@@ -748,39 +774,27 @@ void LLViewerParcelOverlay::renderPropertyLines()
 
         gGL.color4ubv(edge.color.mV);
 
-        for (const LLVector3& vertex : edge.vertices[lod])
+        if (draw_underwater)
         {
-            if (render_hidden || camera_z < water_z || vertex.mV[2] >= water_z)
-            {
-                gGL.vertex3fv(vertex.mV);
-            }
-            else
-            {
-                LLVector3 visible = vertex;
-                visible.mV[VZ] = water_z;
-                gGL.vertex3fv(visible.mV);
-            }
+            gGL.vertexBatchPreTransformed(edge.verticesUnderWater[lod]);
         }
-
-        gGL.end();
-
-        if (render_hidden)
+        else
         {
-            LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_GREATER);
+            gGL.vertexBatchPreTransformed(edge.verticesAboveWater[lod]);
 
-            gGL.begin(LLRender::TRIANGLE_STRIP);
+            if (render_hidden)
+            {
+                LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_GREATER);
 
-            LLColor4U color = edge.color;
-            color.mV[VALPHA] /= 4;
-            gGL.color4ubv(color.mV);
+                LLColor4U color = edge.color;
+                color.mV[VALPHA] /= 4;
+                gGL.color4ubv(color.mV);
 
-            for (const LLVector3& vertex : edge.vertices[lod])
-            {
-                gGL.vertex3fv(vertex.mV);
+                gGL.vertexBatchPreTransformed(edge.verticesUnderWater[lod]);
             }
-
-            gGL.end();
         }
+
+        gGL.end();
     }
 
     gGL.popMatrix();
diff --git a/indra/newview/llviewerparceloverlay.h b/indra/newview/llviewerparceloverlay.h
index 68900d16a6..7271c85701 100644
--- a/indra/newview/llviewerparceloverlay.h
+++ b/indra/newview/llviewerparceloverlay.h
@@ -116,7 +116,10 @@ private:
 
     struct Edge
     {
-        std::vector<LLVector3> vertices[2]; // 0 - detailized, 1 - simplified
+        void pushVertex(U32 lod, F32 x, F32 y, F32 z, F32 water_z);
+        // LOD: 0 - detailized, 1 - simplified
+        std::vector<LLVector4a> verticesAboveWater[2];
+        std::vector<LLVector4a> verticesUnderWater[2];
         LLColor4U color;
     };