Merge branch 'marchcat/w-whitespace' into marchcat/x-ws-merge

1 files changed, 507 insertions, 507 deletions

diff --git a/indra/newview/llviewerparceloverlay.cpp b/indra/newview/llviewerparceloverlay.cpp
index 5a2b7e4c2f..5c9dbcea76 100755
--- a/indra/newview/llviewerparceloverlay.cpp
+++ b/indra/newview/llviewerparceloverlay.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llviewerparceloverlay.cpp
  * @brief LLViewerParcelOverlay class implementation
  *
  * $LicenseInfo:firstyear=2002&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -54,49 +54,49 @@ static const U8  OVERLAY_IMG_COMPONENTS = 4;
 static const F32 LINE_WIDTH = 0.0625f;
 
 LLViewerParcelOverlay::LLViewerParcelOverlay(LLViewerRegion* region, F32 region_width_meters)
-:	mRegion( region ),
-	mParcelGridsPerEdge( S32( region_width_meters / PARCEL_GRID_STEP_METERS ) ),
-	mDirty( FALSE ),
-	mTimeSinceLastUpdate(),
-	mOverlayTextureIdx(-1)
+:   mRegion( region ),
+    mParcelGridsPerEdge( S32( region_width_meters / PARCEL_GRID_STEP_METERS ) ),
+    mDirty( FALSE ),
+    mTimeSinceLastUpdate(),
+    mOverlayTextureIdx(-1)
 {
-	// Create a texture to hold color information.
-	// 4 components
-	// Use mipmaps = FALSE, clamped, NEAREST filter, for sharp edges	
-	mImageRaw = new LLImageRaw(mParcelGridsPerEdge, mParcelGridsPerEdge, OVERLAY_IMG_COMPONENTS);
-	mTexture = LLViewerTextureManager::getLocalTexture(mImageRaw.get(), FALSE);
-	mTexture->setAddressMode(LLTexUnit::TAM_CLAMP);
-	mTexture->setFilteringOption(LLTexUnit::TFO_POINT);
-
-	//
-	// Initialize the GL texture with empty data.
-	//
-	// Create the base texture.
-	U8 *raw = mImageRaw->getData();
-	const S32 COUNT = mParcelGridsPerEdge * mParcelGridsPerEdge * OVERLAY_IMG_COMPONENTS;
-	for (S32 i = 0; i < COUNT; i++)
-	{
-		raw[i] = 0;
-	}
-	//mTexture->setSubImage(mImageRaw, 0, 0, mParcelGridsPerEdge, mParcelGridsPerEdge);
-
-	// Create storage for ownership information from simulator
-	// and initialize it.
-	mOwnership = new U8[ mParcelGridsPerEdge * mParcelGridsPerEdge ];
-	for (S32 i = 0; i < mParcelGridsPerEdge * mParcelGridsPerEdge; i++)
-	{
-		mOwnership[i] = PARCEL_PUBLIC;
-	}
-
-	gPipeline.markGLRebuild(this);
+    // Create a texture to hold color information.
+    // 4 components
+    // Use mipmaps = FALSE, clamped, NEAREST filter, for sharp edges
+    mImageRaw = new LLImageRaw(mParcelGridsPerEdge, mParcelGridsPerEdge, OVERLAY_IMG_COMPONENTS);
+    mTexture = LLViewerTextureManager::getLocalTexture(mImageRaw.get(), FALSE);
+    mTexture->setAddressMode(LLTexUnit::TAM_CLAMP);
+    mTexture->setFilteringOption(LLTexUnit::TFO_POINT);
+
+    //
+    // Initialize the GL texture with empty data.
+    //
+    // Create the base texture.
+    U8 *raw = mImageRaw->getData();
+    const S32 COUNT = mParcelGridsPerEdge * mParcelGridsPerEdge * OVERLAY_IMG_COMPONENTS;
+    for (S32 i = 0; i < COUNT; i++)
+    {
+        raw[i] = 0;
+    }
+    //mTexture->setSubImage(mImageRaw, 0, 0, mParcelGridsPerEdge, mParcelGridsPerEdge);
+
+    // Create storage for ownership information from simulator
+    // and initialize it.
+    mOwnership = new U8[ mParcelGridsPerEdge * mParcelGridsPerEdge ];
+    for (S32 i = 0; i < mParcelGridsPerEdge * mParcelGridsPerEdge; i++)
+    {
+        mOwnership[i] = PARCEL_PUBLIC;
+    }
+
+    gPipeline.markGLRebuild(this);
 }
 
 
 LLViewerParcelOverlay::~LLViewerParcelOverlay()
 {
-	delete[] mOwnership;
-	mOwnership = NULL;
-	mImageRaw = NULL;
+    delete[] mOwnership;
+    mOwnership = NULL;
+    mImageRaw = NULL;
 }
 
 //---------------------------------------------------------------------------
@@ -104,160 +104,160 @@ LLViewerParcelOverlay::~LLViewerParcelOverlay()
 //---------------------------------------------------------------------------
 BOOL LLViewerParcelOverlay::isOwned(const LLVector3& pos) const
 {
-	S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
-	S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
-	return (PARCEL_PUBLIC != ownership(row, column));
+    S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
+    S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
+    return (PARCEL_PUBLIC != ownership(row, column));
 }
 
 BOOL LLViewerParcelOverlay::isOwnedSelf(const LLVector3& pos) const
 {
-	S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
-	S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
-	return (PARCEL_SELF == ownership(row, column));
+    S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
+    S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
+    return (PARCEL_SELF == ownership(row, column));
 }
 
 BOOL LLViewerParcelOverlay::isOwnedGroup(const LLVector3& pos) const
 {
-	S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
-	S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
-	return (PARCEL_GROUP == ownership(row, column));
+    S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
+    S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
+    return (PARCEL_GROUP == ownership(row, column));
 }
 
 BOOL LLViewerParcelOverlay::isOwnedOther(const LLVector3& pos) const
 {
-	S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
-	S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
-	U8 overlay = ownership(row, column);
-	return (PARCEL_OWNED == overlay || PARCEL_FOR_SALE == overlay);
+    S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
+    S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
+    U8 overlay = ownership(row, column);
+    return (PARCEL_OWNED == overlay || PARCEL_FOR_SALE == overlay);
 }
 
 bool LLViewerParcelOverlay::encroachesOwned(const std::vector<LLBBox>& boxes) const
 {
-	// boxes are expected to already be axis aligned
-	for (U32 i = 0; i < boxes.size(); ++i)
-	{
-		LLVector3 min = boxes[i].getMinAgent();
-		LLVector3 max = boxes[i].getMaxAgent();
-		
-		S32 left   = S32(llclamp((min.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		S32 right  = S32(llclamp((max.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		S32 top    = S32(llclamp((min.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		S32 bottom = S32(llclamp((max.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-	
-		for (S32 row = top; row <= bottom; row++)
-		{
-			for (S32 column = left; column <= right; column++)
-			{
-				U8 type = ownership(row, column);
-				if ((PARCEL_SELF == type)
-					|| (PARCEL_GROUP == type))
-				{
-					return true;
-				}
-			}
-		}
-	}
-	return false;
+    // boxes are expected to already be axis aligned
+    for (U32 i = 0; i < boxes.size(); ++i)
+    {
+        LLVector3 min = boxes[i].getMinAgent();
+        LLVector3 max = boxes[i].getMaxAgent();
+
+        S32 left   = S32(llclamp((min.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+        S32 right  = S32(llclamp((max.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+        S32 top    = S32(llclamp((min.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+        S32 bottom = S32(llclamp((max.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+
+        for (S32 row = top; row <= bottom; row++)
+        {
+            for (S32 column = left; column <= right; column++)
+            {
+                U8 type = ownership(row, column);
+                if ((PARCEL_SELF == type)
+                    || (PARCEL_GROUP == type))
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
 }
 bool LLViewerParcelOverlay::encroachesOnUnowned(const std::vector<LLBBox>& boxes) const
 {
-	// boxes are expected to already be axis aligned
-	for (U32 i = 0; i < boxes.size(); ++i)
-	{
-		LLVector3 min = boxes[i].getMinAgent();
-		LLVector3 max = boxes[i].getMaxAgent();
-		
-		S32 left   = S32(llclamp((min.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		S32 right  = S32(llclamp((max.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		S32 top    = S32(llclamp((min.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		S32 bottom = S32(llclamp((max.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		
-		for (S32 row = top; row <= bottom; row++)
-		{
-			for (S32 column = left; column <= right; column++)
-			{
-				U8 type = ownership(row, column);
-				if ((PARCEL_SELF != type))
-				{
-					return true;
-				}
-			}
-		}
-	}
-	return false;
+    // boxes are expected to already be axis aligned
+    for (U32 i = 0; i < boxes.size(); ++i)
+    {
+        LLVector3 min = boxes[i].getMinAgent();
+        LLVector3 max = boxes[i].getMaxAgent();
+
+        S32 left   = S32(llclamp((min.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+        S32 right  = S32(llclamp((max.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+        S32 top    = S32(llclamp((min.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+        S32 bottom = S32(llclamp((max.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+
+        for (S32 row = top; row <= bottom; row++)
+        {
+            for (S32 column = left; column <= right; column++)
+            {
+                U8 type = ownership(row, column);
+                if ((PARCEL_SELF != type))
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
 }
 
 bool LLViewerParcelOverlay::encroachesOnNearbyParcel(const std::vector<LLBBox>& boxes) const
 {
-	// boxes are expected to already be axis aligned
-	for (U32 i = 0; i < boxes.size(); ++i)
-	{
-		LLVector3 min = boxes[i].getMinAgent();
-		LLVector3 max = boxes[i].getMaxAgent();
-
-		// If an object crosses region borders it crosses a parcel
-		if (   min.mV[VX] < 0
-			|| min.mV[VY] < 0
-			|| max.mV[VX] > REGION_WIDTH_METERS
-			|| max.mV[VY] > REGION_WIDTH_METERS)
-		{
-			return true;
-		}
-
-		S32 left   = S32(llclamp((min.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		S32 right  = S32(llclamp((max.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		S32 bottom = S32(llclamp((min.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-		S32 top    = S32(llclamp((max.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
-
-		const S32 GRIDS_PER_EDGE = mParcelGridsPerEdge;
-
-		for (S32 row = bottom; row <= top; row++)
-		{
-			for (S32 col = left; col <= right; col++)
-			{
-				// This is not the rightmost column
-				if (col < GRIDS_PER_EDGE-1)
-				{
-					U8 east_overlay = mOwnership[row*GRIDS_PER_EDGE+col+1];
-					// If the column to the east of the current one marks
-					// the other parcel's west edge and the box extends
-					// to the west it crosses the parcel border.
-					if ((east_overlay & PARCEL_WEST_LINE) && col < right)
-					{
-						return true;
-					}
-				}
-
-				// This is not the topmost column
-				if (row < GRIDS_PER_EDGE-1)
-				{
-					U8 north_overlay = mOwnership[(row+1)*GRIDS_PER_EDGE+col];
-					// If the row to the north of the current one marks
-					// the other parcel's south edge and the box extends
-					// to the south it crosses the parcel border.
-					if ((north_overlay & PARCEL_SOUTH_LINE) && row < top)
-					{
-						return true;
-					}
-				}
-			}
-		}
-	}
-	return false;
+    // boxes are expected to already be axis aligned
+    for (U32 i = 0; i < boxes.size(); ++i)
+    {
+        LLVector3 min = boxes[i].getMinAgent();
+        LLVector3 max = boxes[i].getMaxAgent();
+
+        // If an object crosses region borders it crosses a parcel
+        if (   min.mV[VX] < 0
+            || min.mV[VY] < 0
+            || max.mV[VX] > REGION_WIDTH_METERS
+            || max.mV[VY] > REGION_WIDTH_METERS)
+        {
+            return true;
+        }
+
+        S32 left   = S32(llclamp((min.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+        S32 right  = S32(llclamp((max.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+        S32 bottom = S32(llclamp((min.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+        S32 top    = S32(llclamp((max.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1));
+
+        const S32 GRIDS_PER_EDGE = mParcelGridsPerEdge;
+
+        for (S32 row = bottom; row <= top; row++)
+        {
+            for (S32 col = left; col <= right; col++)
+            {
+                // This is not the rightmost column
+                if (col < GRIDS_PER_EDGE-1)
+                {
+                    U8 east_overlay = mOwnership[row*GRIDS_PER_EDGE+col+1];
+                    // If the column to the east of the current one marks
+                    // the other parcel's west edge and the box extends
+                    // to the west it crosses the parcel border.
+                    if ((east_overlay & PARCEL_WEST_LINE) && col < right)
+                    {
+                        return true;
+                    }
+                }
+
+                // This is not the topmost column
+                if (row < GRIDS_PER_EDGE-1)
+                {
+                    U8 north_overlay = mOwnership[(row+1)*GRIDS_PER_EDGE+col];
+                    // If the row to the north of the current one marks
+                    // the other parcel's south edge and the box extends
+                    // to the south it crosses the parcel border.
+                    if ((north_overlay & PARCEL_SOUTH_LINE) && row < top)
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
 }
 
 BOOL LLViewerParcelOverlay::isSoundLocal(const LLVector3& pos) const
 {
-	S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
-	S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
+    S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
+    S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
     return parcelFlags(row, column, PARCEL_SOUND_LOCAL);
 }
 
 U8 LLViewerParcelOverlay::ownership( const LLVector3& pos) const
 {
-	S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
-	S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
-	return ownership(row, column);
+    S32 row =    S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS);
+    S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS);
+    return ownership(row, column);
 }
 
 U8 LLViewerParcelOverlay::parcelLineFlags(const LLVector3& pos) const
@@ -286,18 +286,18 @@ U8 LLViewerParcelOverlay::parcelFlags(S32 row, S32 col, U8 flags) const
 
 F32 LLViewerParcelOverlay::getOwnedRatio() const
 {
-	S32	size = mParcelGridsPerEdge * mParcelGridsPerEdge;
-	S32 total = 0;
-
-	for (S32 i = 0; i < size; i++)
-	{
-		if ((mOwnership[i] & PARCEL_COLOR_MASK) != PARCEL_PUBLIC)
-		{
-			total++;
-		}
-	}
-
-	return (F32)total / (F32)size;
+    S32 size = mParcelGridsPerEdge * mParcelGridsPerEdge;
+    S32 total = 0;
+
+    for (S32 i = 0; i < size; i++)
+    {
+        if ((mOwnership[i] & PARCEL_COLOR_MASK) != PARCEL_PUBLIC)
+        {
+            total++;
+        }
+    }
+
+    return (F32)total / (F32)size;
 }
 
 //---------------------------------------------------------------------------
@@ -311,210 +311,210 @@ F32 LLViewerParcelOverlay::getOwnedRatio() const
 // Self      = index 3
 
 // Make sure the texture colors match the ownership data.
-// Note: Assumes that the ownership array and 
+// Note: Assumes that the ownership array and
 void LLViewerParcelOverlay::updateOverlayTexture()
 {
-	if (mOverlayTextureIdx < 0)
-	{
-		if (!mDirty)
-			return;
-		mOverlayTextureIdx = 0;
-	}
-
-	const LLColor4U avail = LLUIColorTable::instance().getColor("PropertyColorAvail").get();
-	const LLColor4U owned = LLUIColorTable::instance().getColor("PropertyColorOther").get();
-	const LLColor4U group = LLUIColorTable::instance().getColor("PropertyColorGroup").get();
-	const LLColor4U self  = LLUIColorTable::instance().getColor("PropertyColorSelf").get();
-	const LLColor4U for_sale  = LLUIColorTable::instance().getColor("PropertyColorForSale").get();
-	const LLColor4U auction  = LLUIColorTable::instance().getColor("PropertyColorAuction").get();
-
-	// Create the base texture.
-	U8 *raw = mImageRaw->getData();
-	const S32 COUNT = mParcelGridsPerEdge * mParcelGridsPerEdge;
-	S32 max = mOverlayTextureIdx + mParcelGridsPerEdge;
-	if (max > COUNT) max = COUNT;
-	S32 pixel_index = mOverlayTextureIdx*OVERLAY_IMG_COMPONENTS;
-	S32 i;
-	for (i = mOverlayTextureIdx; i < max; i++)
-	{
-		U8 ownership = mOwnership[i];
-
-		F32 r,g,b,a;
-
-		// Color stored in low three bits
-		switch( ownership & 0x7 )
-		{
-		case PARCEL_PUBLIC:
-			r = avail.mV[VRED];
-			g = avail.mV[VGREEN];
-			b = avail.mV[VBLUE];
-			a = avail.mV[VALPHA];
-			break;
-		case PARCEL_OWNED:
-			r = owned.mV[VRED];
-			g = owned.mV[VGREEN];
-			b = owned.mV[VBLUE];
-			a = owned.mV[VALPHA];
-			break;
-		case PARCEL_GROUP:
-			r = group.mV[VRED];
-			g = group.mV[VGREEN];
-			b = group.mV[VBLUE];
-			a = group.mV[VALPHA];
-			break;
-		case PARCEL_SELF:
-			r = self.mV[VRED];
-			g = self.mV[VGREEN];
-			b = self.mV[VBLUE];
-			a = self.mV[VALPHA];
-			break;
-		case PARCEL_FOR_SALE:
-			r = for_sale.mV[VRED];
-			g = for_sale.mV[VGREEN];
-			b = for_sale.mV[VBLUE];
-			a = for_sale.mV[VALPHA];
-			break;
-		case PARCEL_AUCTION:
-			r = auction.mV[VRED];
-			g = auction.mV[VGREEN];
-			b = auction.mV[VBLUE];
-			a = auction.mV[VALPHA];
-			break;
-		default:
-			r = self.mV[VRED];
-			g = self.mV[VGREEN];
-			b = self.mV[VBLUE];
-			a = self.mV[VALPHA];
-			break;
-		}
-
-		raw[pixel_index + 0] = (U8)r;
-		raw[pixel_index + 1] = (U8)g;
-		raw[pixel_index + 2] = (U8)b;
-		raw[pixel_index + 3] = (U8)a;
-
-		pixel_index += OVERLAY_IMG_COMPONENTS;
-	}
-	
-	// Copy data into GL texture from raw data
-	if (i >= COUNT)
-	{
-		if (!mTexture->hasGLTexture())
-		{
-			mTexture->createGLTexture(0, mImageRaw);
-		}
-		mTexture->setSubImage(mImageRaw, 0, 0, mParcelGridsPerEdge, mParcelGridsPerEdge);
-		mOverlayTextureIdx = -1;
-	}
-	else
-	{
-		mOverlayTextureIdx = i;
-	}
+    if (mOverlayTextureIdx < 0)
+    {
+        if (!mDirty)
+            return;
+        mOverlayTextureIdx = 0;
+    }
+
+    const LLColor4U avail = LLUIColorTable::instance().getColor("PropertyColorAvail").get();
+    const LLColor4U owned = LLUIColorTable::instance().getColor("PropertyColorOther").get();
+    const LLColor4U group = LLUIColorTable::instance().getColor("PropertyColorGroup").get();
+    const LLColor4U self  = LLUIColorTable::instance().getColor("PropertyColorSelf").get();
+    const LLColor4U for_sale  = LLUIColorTable::instance().getColor("PropertyColorForSale").get();
+    const LLColor4U auction  = LLUIColorTable::instance().getColor("PropertyColorAuction").get();
+
+    // Create the base texture.
+    U8 *raw = mImageRaw->getData();
+    const S32 COUNT = mParcelGridsPerEdge * mParcelGridsPerEdge;
+    S32 max = mOverlayTextureIdx + mParcelGridsPerEdge;
+    if (max > COUNT) max = COUNT;
+    S32 pixel_index = mOverlayTextureIdx*OVERLAY_IMG_COMPONENTS;
+    S32 i;
+    for (i = mOverlayTextureIdx; i < max; i++)
+    {
+        U8 ownership = mOwnership[i];
+
+        F32 r,g,b,a;
+
+        // Color stored in low three bits
+        switch( ownership & 0x7 )
+        {
+        case PARCEL_PUBLIC:
+            r = avail.mV[VRED];
+            g = avail.mV[VGREEN];
+            b = avail.mV[VBLUE];
+            a = avail.mV[VALPHA];
+            break;
+        case PARCEL_OWNED:
+            r = owned.mV[VRED];
+            g = owned.mV[VGREEN];
+            b = owned.mV[VBLUE];
+            a = owned.mV[VALPHA];
+            break;
+        case PARCEL_GROUP:
+            r = group.mV[VRED];
+            g = group.mV[VGREEN];
+            b = group.mV[VBLUE];
+            a = group.mV[VALPHA];
+            break;
+        case PARCEL_SELF:
+            r = self.mV[VRED];
+            g = self.mV[VGREEN];
+            b = self.mV[VBLUE];
+            a = self.mV[VALPHA];
+            break;
+        case PARCEL_FOR_SALE:
+            r = for_sale.mV[VRED];
+            g = for_sale.mV[VGREEN];
+            b = for_sale.mV[VBLUE];
+            a = for_sale.mV[VALPHA];
+            break;
+        case PARCEL_AUCTION:
+            r = auction.mV[VRED];
+            g = auction.mV[VGREEN];
+            b = auction.mV[VBLUE];
+            a = auction.mV[VALPHA];
+            break;
+        default:
+            r = self.mV[VRED];
+            g = self.mV[VGREEN];
+            b = self.mV[VBLUE];
+            a = self.mV[VALPHA];
+            break;
+        }
+
+        raw[pixel_index + 0] = (U8)r;
+        raw[pixel_index + 1] = (U8)g;
+        raw[pixel_index + 2] = (U8)b;
+        raw[pixel_index + 3] = (U8)a;
+
+        pixel_index += OVERLAY_IMG_COMPONENTS;
+    }
+
+    // Copy data into GL texture from raw data
+    if (i >= COUNT)
+    {
+        if (!mTexture->hasGLTexture())
+        {
+            mTexture->createGLTexture(0, mImageRaw);
+        }
+        mTexture->setSubImage(mImageRaw, 0, 0, mParcelGridsPerEdge, mParcelGridsPerEdge);
+        mOverlayTextureIdx = -1;
+    }
+    else
+    {
+        mOverlayTextureIdx = i;
+    }
 }
 
 
 void LLViewerParcelOverlay::uncompressLandOverlay(S32 chunk, U8 *packed_overlay)
 {
-	// Unpack the message data into the ownership array
-	S32	size	= mParcelGridsPerEdge * mParcelGridsPerEdge;
-	S32 chunk_size = size / PARCEL_OVERLAY_CHUNKS;
+    // Unpack the message data into the ownership array
+    S32 size    = mParcelGridsPerEdge * mParcelGridsPerEdge;
+    S32 chunk_size = size / PARCEL_OVERLAY_CHUNKS;
 
-	memcpy(mOwnership + chunk*chunk_size, packed_overlay, chunk_size);		/*Flawfinder: ignore*/
+    memcpy(mOwnership + chunk*chunk_size, packed_overlay, chunk_size);      /*Flawfinder: ignore*/
 
-	// Force property lines and overlay texture to update
-	setDirty();
+    // Force property lines and overlay texture to update
+    setDirty();
 }
 
 void LLViewerParcelOverlay::updatePropertyLines()
 {
-	static LLCachedControl<bool> show(gSavedSettings, "ShowPropertyLines");
-
-	if (!show)
-		return;
-
-	LLColor4U colors[PARCEL_COLOR_MASK + 1];
-	colors[PARCEL_SELF] = LLUIColorTable::instance().getColor("PropertyColorSelf").get();
-	colors[PARCEL_OWNED] = LLUIColorTable::instance().getColor("PropertyColorOther").get();
-	colors[PARCEL_GROUP] = LLUIColorTable::instance().getColor("PropertyColorGroup").get();
-	colors[PARCEL_FOR_SALE] = LLUIColorTable::instance().getColor("PropertyColorForSale").get();
-	colors[PARCEL_AUCTION] = LLUIColorTable::instance().getColor("PropertyColorAuction").get();
-
-	mEdges.clear();
-
-	const F32 GRID_STEP = PARCEL_GRID_STEP_METERS;
-	const S32 GRIDS_PER_EDGE = mParcelGridsPerEdge;
-
-	for (S32 row = 0; row < GRIDS_PER_EDGE; row++)
-	{
-		for (S32 col = 0; col < GRIDS_PER_EDGE; col++)
-		{
-			U8 overlay = mOwnership[row*GRIDS_PER_EDGE+col];
-			S32 colorIndex = overlay & PARCEL_COLOR_MASK;
-			switch(colorIndex)
-			{
-			case PARCEL_SELF:
-			case PARCEL_GROUP:
-			case PARCEL_OWNED:
-			case PARCEL_FOR_SALE:
-			case PARCEL_AUCTION:
-				break;
-			default:
-				continue;
-			}
-
-			const LLColor4U& color = colors[colorIndex];
-
-			F32 left = col*GRID_STEP;
-			F32 right = left+GRID_STEP;
-
-			F32 bottom = row*GRID_STEP;
-			F32 top = bottom+GRID_STEP;
-
-			// West edge
-			if (overlay & PARCEL_WEST_LINE)
-			{
-				addPropertyLine(left, bottom, 0, 1, LINE_WIDTH, 0, color);
-			}
-
-			// East edge
-			if (col == GRIDS_PER_EDGE - 1 || mOwnership[row * GRIDS_PER_EDGE + col + 1] & PARCEL_WEST_LINE)
-			{
-				addPropertyLine(right, bottom, 0, 1, -LINE_WIDTH, 0, color);
-			}
-
-			// South edge
-			if (overlay & PARCEL_SOUTH_LINE)
-			{
-				addPropertyLine(left, bottom, 1, 0, 0, LINE_WIDTH, color);
-			}
-
-			// North edge
-			if (row == GRIDS_PER_EDGE - 1 || mOwnership[(row + 1) * GRIDS_PER_EDGE + col] & PARCEL_SOUTH_LINE)
-			{
-				addPropertyLine(left, top, 1, 0, 0, -LINE_WIDTH, color);
-			}
-		}
-	}
-	
-	// Everything's clean now
-	mDirty = FALSE;
+    static LLCachedControl<bool> show(gSavedSettings, "ShowPropertyLines");
+
+    if (!show)
+        return;
+
+    LLColor4U colors[PARCEL_COLOR_MASK + 1];
+    colors[PARCEL_SELF] = LLUIColorTable::instance().getColor("PropertyColorSelf").get();
+    colors[PARCEL_OWNED] = LLUIColorTable::instance().getColor("PropertyColorOther").get();
+    colors[PARCEL_GROUP] = LLUIColorTable::instance().getColor("PropertyColorGroup").get();
+    colors[PARCEL_FOR_SALE] = LLUIColorTable::instance().getColor("PropertyColorForSale").get();
+    colors[PARCEL_AUCTION] = LLUIColorTable::instance().getColor("PropertyColorAuction").get();
+
+    mEdges.clear();
+
+    const F32 GRID_STEP = PARCEL_GRID_STEP_METERS;
+    const S32 GRIDS_PER_EDGE = mParcelGridsPerEdge;
+
+    for (S32 row = 0; row < GRIDS_PER_EDGE; row++)
+    {
+        for (S32 col = 0; col < GRIDS_PER_EDGE; col++)
+        {
+            U8 overlay = mOwnership[row*GRIDS_PER_EDGE+col];
+            S32 colorIndex = overlay & PARCEL_COLOR_MASK;
+            switch(colorIndex)
+            {
+            case PARCEL_SELF:
+            case PARCEL_GROUP:
+            case PARCEL_OWNED:
+            case PARCEL_FOR_SALE:
+            case PARCEL_AUCTION:
+                break;
+            default:
+                continue;
+            }
+
+            const LLColor4U& color = colors[colorIndex];
+
+            F32 left = col*GRID_STEP;
+            F32 right = left+GRID_STEP;
+
+            F32 bottom = row*GRID_STEP;
+            F32 top = bottom+GRID_STEP;
+
+            // West edge
+            if (overlay & PARCEL_WEST_LINE)
+            {
+                addPropertyLine(left, bottom, 0, 1, LINE_WIDTH, 0, color);
+            }
+
+            // East edge
+            if (col == GRIDS_PER_EDGE - 1 || mOwnership[row * GRIDS_PER_EDGE + col + 1] & PARCEL_WEST_LINE)
+            {
+                addPropertyLine(right, bottom, 0, 1, -LINE_WIDTH, 0, color);
+            }
+
+            // South edge
+            if (overlay & PARCEL_SOUTH_LINE)
+            {
+                addPropertyLine(left, bottom, 1, 0, 0, LINE_WIDTH, color);
+            }
+
+            // North edge
+            if (row == GRIDS_PER_EDGE - 1 || mOwnership[(row + 1) * GRIDS_PER_EDGE + col] & PARCEL_SOUTH_LINE)
+            {
+                addPropertyLine(left, top, 1, 0, 0, -LINE_WIDTH, color);
+            }
+        }
+    }
+
+    // Everything's clean now
+    mDirty = FALSE;
 }
 
 void LLViewerParcelOverlay::addPropertyLine(F32 start_x, F32 start_y, F32 dx, F32 dy, F32 tick_dx, F32 tick_dy, const LLColor4U& color)
 {
-	LLSurface& land = mRegion->getLand();
-	F32 water_z = land.getWaterHeight();
+    LLSurface& land = mRegion->getLand();
+    F32 water_z = land.getWaterHeight();
 
-	mEdges.resize(mEdges.size() + 1);
-	Edge& edge = mEdges.back();
-	edge.color = color;
+    mEdges.resize(mEdges.size() + 1);
+    Edge& edge = mEdges.back();
+    edge.color = color;
 
-	F32 outside_x = start_x;
-	F32 outside_y = start_y;
-	F32 outside_z = 0.f;
-	F32 inside_x  = start_x + tick_dx;
-	F32 inside_y  = start_y + tick_dy;
-	F32 inside_z  = 0.f;
+    F32 outside_x = start_x;
+    F32 outside_y = start_y;
+    F32 outside_z = 0.f;
+    F32 inside_x  = start_x + tick_dx;
+    F32 inside_y  = start_y + tick_dy;
+    F32 inside_z  = 0.f;
 
     auto split = [&](const LLVector3& start, F32 x, F32 y, F32 z, F32 part)
         {
@@ -537,217 +537,217 @@ void LLViewerParcelOverlay::addPropertyLine(F32 start_x, F32 start_y, F32 dx, F3
             split(last_outside, outside_x, outside_y, outside_z, part);
         };
 
-	// First part, only one vertex
-	outside_z = land.resolveHeightRegion( outside_x, outside_y );
+    // First part, only one vertex
+    outside_z = land.resolveHeightRegion( outside_x, outside_y );
 
-	edge.vertices.emplace_back(outside_x, outside_y, outside_z);
+    edge.vertices.emplace_back(outside_x, outside_y, outside_z);
 
-	inside_x += dx * LINE_WIDTH;
-	inside_y += dy * LINE_WIDTH;
+    inside_x += dx * LINE_WIDTH;
+    inside_y += dy * LINE_WIDTH;
 
-	outside_x += dx * LINE_WIDTH;
-	outside_y += dy * LINE_WIDTH;
+    outside_x += dx * LINE_WIDTH;
+    outside_y += dy * LINE_WIDTH;
 
-	// Then the "actual edge"
-	inside_z = land.resolveHeightRegion( inside_x, inside_y );
-	outside_z = land.resolveHeightRegion( outside_x, outside_y );
+    // Then the "actual edge"
+    inside_z = land.resolveHeightRegion( inside_x, inside_y );
+    outside_z = land.resolveHeightRegion( outside_x, outside_y );
 
-	edge.vertices.emplace_back(inside_x, inside_y, inside_z);
-	edge.vertices.emplace_back(outside_x, outside_y, outside_z);
+    edge.vertices.emplace_back(inside_x, inside_y, inside_z);
+    edge.vertices.emplace_back(outside_x, outside_y, outside_z);
 
-	inside_x += dx * (dx - LINE_WIDTH);
-	inside_y += dy * (dy - LINE_WIDTH);
+    inside_x += dx * (dx - LINE_WIDTH);
+    inside_y += dy * (dy - LINE_WIDTH);
 
-	outside_x += dx * (dx - LINE_WIDTH);
-	outside_y += dy * (dy - LINE_WIDTH);
+    outside_x += dx * (dx - LINE_WIDTH);
+    outside_y += dy * (dy - LINE_WIDTH);
 
-	// Middle part, full width
-	const S32 GRID_STEP = S32( PARCEL_GRID_STEP_METERS );
-	for (S32 i = 1; i < GRID_STEP; i++)
-	{
-		inside_z = land.resolveHeightRegion( inside_x, inside_y );
-		outside_z = land.resolveHeightRegion( outside_x, outside_y );
+    // Middle part, full width
+    const S32 GRID_STEP = S32( PARCEL_GRID_STEP_METERS );
+    for (S32 i = 1; i < GRID_STEP; i++)
+    {
+        inside_z = land.resolveHeightRegion( inside_x, inside_y );
+        outside_z = land.resolveHeightRegion( outside_x, outside_y );
 
-		checkForSplit();
+        checkForSplit();
 
-		edge.vertices.emplace_back(inside_x, inside_y, inside_z);
-		edge.vertices.emplace_back(outside_x, outside_y, outside_z);
+        edge.vertices.emplace_back(inside_x, inside_y, inside_z);
+        edge.vertices.emplace_back(outside_x, outside_y, outside_z);
 
-		inside_x += dx;
-		inside_y += dy;
+        inside_x += dx;
+        inside_y += dy;
 
-		outside_x += dx;
-		outside_y += dy;
-	}
+        outside_x += dx;
+        outside_y += dy;
+    }
 
-	// Extra buffer for edge
-	inside_x -= dx * LINE_WIDTH;
-	inside_y -= dy * LINE_WIDTH;
+    // Extra buffer for edge
+    inside_x -= dx * LINE_WIDTH;
+    inside_y -= dy * LINE_WIDTH;
 
-	outside_x -= dx * LINE_WIDTH;
-	outside_y -= dy * LINE_WIDTH;
+    outside_x -= dx * LINE_WIDTH;
+    outside_y -= dy * LINE_WIDTH;
 
-	inside_z = land.resolveHeightRegion( inside_x, inside_y );
-	outside_z = land.resolveHeightRegion( outside_x, outside_y );
+    inside_z = land.resolveHeightRegion( inside_x, inside_y );
+    outside_z = land.resolveHeightRegion( outside_x, outside_y );
 
-	checkForSplit();
+    checkForSplit();
 
-	edge.vertices.emplace_back(inside_x, inside_y, inside_z);
-	edge.vertices.emplace_back(outside_x, outside_y, outside_z);
+    edge.vertices.emplace_back(inside_x, inside_y, inside_z);
+    edge.vertices.emplace_back(outside_x, outside_y, outside_z);
 
-	outside_x += dx * LINE_WIDTH;
-	outside_y += dy * LINE_WIDTH;
+    outside_x += dx * LINE_WIDTH;
+    outside_y += dy * LINE_WIDTH;
 
-	// Last edge is not drawn to the edge
-	outside_z = land.resolveHeightRegion( outside_x, outside_y );
+    // Last edge is not drawn to the edge
+    outside_z = land.resolveHeightRegion( outside_x, outside_y );
 
-	edge.vertices.emplace_back(outside_x, outside_y, outside_z);
+    edge.vertices.emplace_back(outside_x, outside_y, outside_z);
 }
 
 void LLViewerParcelOverlay::setDirty()
 {
-	mDirty = TRUE;
+    mDirty = TRUE;
 }
 
 void LLViewerParcelOverlay::updateGL()
 {
-	LL_PROFILE_ZONE_SCOPED
-	updateOverlayTexture();
+    LL_PROFILE_ZONE_SCOPED
+    updateOverlayTexture();
 }
 
 void LLViewerParcelOverlay::idleUpdate(bool force_update)
 {
-	if (gGLManager.mIsDisabled)
-	{
-		return;
-	}
-	if (mOverlayTextureIdx >= 0 && (!(mDirty && force_update)))
-	{
-		// We are in the middle of updating the overlay texture
-		gPipeline.markGLRebuild(this);
-		return;
-	}
-	// Only if we're dirty and it's been a while since the last update.
-	if (mDirty)
-	{
-		if (force_update || mTimeSinceLastUpdate.getElapsedTimeF32() > 4.0f)
-		{
-			updateOverlayTexture();
-			updatePropertyLines();
-			mTimeSinceLastUpdate.reset();
-		}
-	}
+    if (gGLManager.mIsDisabled)
+    {
+        return;
+    }
+    if (mOverlayTextureIdx >= 0 && (!(mDirty && force_update)))
+    {
+        // We are in the middle of updating the overlay texture
+        gPipeline.markGLRebuild(this);
+        return;
+    }
+    // Only if we're dirty and it's been a while since the last update.
+    if (mDirty)
+    {
+        if (force_update || mTimeSinceLastUpdate.getElapsedTimeF32() > 4.0f)
+        {
+            updateOverlayTexture();
+            updatePropertyLines();
+            mTimeSinceLastUpdate.reset();
+        }
+    }
 }
 
 void LLViewerParcelOverlay::renderPropertyLines()
 {
-	static LLCachedControl<bool> show(gSavedSettings, "ShowPropertyLines");
+    static LLCachedControl<bool> show(gSavedSettings, "ShowPropertyLines");
 
-	if (!show)
-		return;
+    if (!show)
+        return;
 
-	LLSurface& land = mRegion->getLand();
-	F32 water_z = land.getWaterHeight() + 0.01f;
+    LLSurface& land = mRegion->getLand();
+    F32 water_z = land.getWaterHeight() + 0.01f;
 
-	LLGLSUIDefault gls_ui; // called from pipeline
-	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-	LLGLDepthTest mDepthTest(GL_TRUE);
+    LLGLSUIDefault gls_ui; // called from pipeline
+    gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+    LLGLDepthTest mDepthTest(GL_TRUE);
 
-	// Find camera height off the ground (not from zero)
-	F32 ground_height_at_camera = land.resolveHeightGlobal( gAgentCamera.getCameraPositionGlobal() );
-	F32 camera_z = LLViewerCamera::getInstance()->getOrigin().mV[VZ];
-	F32 camera_height = camera_z - ground_height_at_camera;
+    // Find camera height off the ground (not from zero)
+    F32 ground_height_at_camera = land.resolveHeightGlobal( gAgentCamera.getCameraPositionGlobal() );
+    F32 camera_z = LLViewerCamera::getInstance()->getOrigin().mV[VZ];
+    F32 camera_height = camera_z - ground_height_at_camera;
 
-	camera_height = llclamp(camera_height, 0.f, 100.f);
+    camera_height = llclamp(camera_height, 0.f, 100.f);
 
-	// Pull lines toward camera by 1 cm per meter off the ground.
-	const LLVector3& CAMERA_AT = LLViewerCamera::getInstance()->getAtAxis();
-	F32 pull_toward_camera_scale = 0.01f * camera_height;
-	LLVector3 pull_toward_camera = CAMERA_AT;
-	pull_toward_camera *= -pull_toward_camera_scale;
+    // Pull lines toward camera by 1 cm per meter off the ground.
+    const LLVector3& CAMERA_AT = LLViewerCamera::getInstance()->getAtAxis();
+    F32 pull_toward_camera_scale = 0.01f * camera_height;
+    LLVector3 pull_toward_camera = CAMERA_AT;
+    pull_toward_camera *= -pull_toward_camera_scale;
 
-	// Always fudge a little vertically.
-	pull_toward_camera.mV[VZ] += 0.01f;
+    // Always fudge a little vertically.
+    pull_toward_camera.mV[VZ] += 0.01f;
 
     gGL.matrixMode(LLRender::MM_MODELVIEW);
     gGL.pushMatrix();
 
-	// Move to appropriate region coords
-	LLVector3 origin = mRegion->getOriginAgent();
-	gGL.translatef(origin.mV[VX], origin.mV[VY], origin.mV[VZ]);
+    // Move to appropriate region coords
+    LLVector3 origin = mRegion->getOriginAgent();
+    gGL.translatef(origin.mV[VX], origin.mV[VY], origin.mV[VZ]);
 
-	gGL.translatef(pull_toward_camera.mV[VX], pull_toward_camera.mV[VY],
-		pull_toward_camera.mV[VZ]);
+    gGL.translatef(pull_toward_camera.mV[VX], pull_toward_camera.mV[VY],
+        pull_toward_camera.mV[VZ]);
 
-	// Stomp the camera into two dimensions
-	LLVector3 camera_region = mRegion->getPosRegionFromGlobal( gAgentCamera.getCameraPositionGlobal() );
+    // Stomp the camera into two dimensions
+    LLVector3 camera_region = mRegion->getPosRegionFromGlobal( gAgentCamera.getCameraPositionGlobal() );
 
-	// Set up a cull plane 2 * PARCEL_GRID_STEP_METERS behind
-	// the camera.  The cull plane normal is the camera's at axis.
-	LLVector3 cull_plane_point = LLViewerCamera::getInstance()->getAtAxis();
-	cull_plane_point *= -2.f * PARCEL_GRID_STEP_METERS;
-	cull_plane_point += camera_region;
+    // Set up a cull plane 2 * PARCEL_GRID_STEP_METERS behind
+    // the camera.  The cull plane normal is the camera's at axis.
+    LLVector3 cull_plane_point = LLViewerCamera::getInstance()->getAtAxis();
+    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 = LLSelectMgr::sRenderHiddenSelections && LLFloaterReg::instanceVisible("build");
 
-	const F32 PROPERTY_LINE_CLIP_DIST_SQUARED = 256.f * 256.f;
+    const F32 PROPERTY_LINE_CLIP_DIST_SQUARED = 256.f * 256.f;
 
-	for (const Edge& edge : mEdges)
-	{
-		LLVector3 center = edge.vertices[edge.vertices.size() >> 1];
+    for (const Edge& edge : mEdges)
+    {
+        LLVector3 center = edge.vertices[edge.vertices.size() >> 1];
 
-		if (dist_vec_squared2D(center, camera_region) > PROPERTY_LINE_CLIP_DIST_SQUARED)
-		{
-			continue;
-		}
+        if (dist_vec_squared2D(center, camera_region) > PROPERTY_LINE_CLIP_DIST_SQUARED)
+        {
+            continue;
+        }
 
-		// Destroy vertex, transform to plane-local.
-		center -= cull_plane_point;
+        // Destroy vertex, transform to plane-local.
+        center -= cull_plane_point;
 
-		// Negative dot product means it is in back of the plane
-		if (center * CAMERA_AT < 0.f)
-		{
-			continue;
-		}
+        // Negative dot product means it is in back of the plane
+        if (center * CAMERA_AT < 0.f)
+        {
+            continue;
+        }
 
-		gGL.begin(LLRender::TRIANGLE_STRIP);
+        gGL.begin(LLRender::TRIANGLE_STRIP);
 
-		gGL.color4ubv(edge.color.mV);
+        gGL.color4ubv(edge.color.mV);
 
-		for (const LLVector3& vertex : edge.vertices)
-		{
-			if (render_hidden || camera_z < water_z || vertex.mV[2] >= water_z)
-			{
-				gGL.vertex3fv(vertex.mV);
-			}
-			else
-			{
-				LLVector3 visible = vertex;
-				visible.mV[2] = water_z;
-				gGL.vertex3fv(visible.mV);
-			}
-		}
+        for (const LLVector3& vertex : edge.vertices)
+        {
+            if (render_hidden || camera_z < water_z || vertex.mV[2] >= water_z)
+            {
+                gGL.vertex3fv(vertex.mV);
+            }
+            else
+            {
+                LLVector3 visible = vertex;
+                visible.mV[2] = water_z;
+                gGL.vertex3fv(visible.mV);
+            }
+        }
 
-		gGL.end();
+        gGL.end();
 
-		if (render_hidden)
-		{
-			LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_GREATER);
+        if (render_hidden)
+        {
+            LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_GREATER);
 
-			gGL.begin(LLRender::TRIANGLE_STRIP);
+            gGL.begin(LLRender::TRIANGLE_STRIP);
 
-			LLColor4U color = edge.color;
-			color.mV[3] /= 4;
-			gGL.color4ubv(color.mV);
+            LLColor4U color = edge.color;
+            color.mV[3] /= 4;
+            gGL.color4ubv(color.mV);
 
-			for (const LLVector3& vertex : edge.vertices)
-			{
-				gGL.vertex3fv(vertex.mV);
-			}
+            for (const LLVector3& vertex : edge.vertices)
+            {
+                gGL.vertex3fv(vertex.mV);
+            }
 
-			gGL.end();
-		}
-	}
+            gGL.end();
+        }
+    }
 
     gGL.popMatrix();
 }