Applied patch by Aleric Inglewood for VWR-12984: Water flickers and disappears in patches, part 1

28 files changed, 477 insertions, 167 deletions

diff --git a/linden/indra/llrender/llgl.cpp b/linden/indra/llrender/llgl.cpp
index 61194c4..c08ad0d 100644
--- a/linden/indra/llrender/llgl.cpp
+++ b/linden/indra/llrender/llgl.cpp
@@ -552,41 +552,46 @@ extern LLCPUInfo gSysCPU;
 void LLGLManager::initExtensions()
 {
 #if LL_MESA_HEADLESS
-# if GL_ARB_multitexture
+# ifdef GL_ARB_multitexture
         mHasMultitexture = TRUE;
 # else
         mHasMultitexture = FALSE;
 # endif
-# if GL_ARB_texture_env_combine
-        mHasARBEnvCombine = TRUE;       
+# ifdef GL_ARB_texture_env_combine
+        mHasARBEnvCombine = TRUE;
 # else
         mHasARBEnvCombine = FALSE;
 # endif
-# if GL_ARB_texture_compression
+# ifdef GL_ARB_texture_compression
         mHasCompressedTextures = TRUE;
 # else
         mHasCompressedTextures = FALSE;
 # endif
-# if GL_ARB_vertex_buffer_object
+# ifdef GL_ARB_vertex_buffer_object
         mHasVertexBufferObject = TRUE;
 # else
         mHasVertexBufferObject = FALSE;
 # endif
-# if GL_EXT_framebuffer_object
+# ifdef GL_EXT_framebuffer_object
         mHasFramebufferObject = TRUE;
 # else
         mHasFramebufferObject = FALSE;
 # endif
-# if GL_EXT_framebuffer_multisample
+# ifdef GL_EXT_framebuffer_multisample
         mHasFramebufferMultisample = TRUE;
 # else
         mHasFramebufferMultisample = FALSE;
 # endif
-# if GL_ARB_draw_buffers
+# ifdef GL_ARB_draw_buffers
         mHasDrawBuffers = TRUE;
 #else
         mHasDrawBuffers = FALSE;
 # endif
+# if defined(GL_NV_depth_clamp) || defined(GL_ARB_depth_clamp)
+        mHasDepthClamp = TRUE;
+#else
+        mHasDepthClamp = FALSE;
+#endif
         mHasMipMapGeneration = FALSE;
         mHasSeparateSpecularColor = FALSE;
         mHasAnisotropic = FALSE;
@@ -612,6 +617,7 @@ void LLGLManager::initExtensions()
                 && ExtensionExists("GL_EXT_packed_depth_stencil", gGLHExts.mSysExts);
         mHasFramebufferMultisample = mHasFramebufferObject && ExtensionExists("GL_EXT_framebuffer_multisample", gGLHExts.mSysExts);
         mHasDrawBuffers = ExtensionExists("GL_ARB_draw_buffers", gGLHExts.mSysExts);
+        mHasDepthClamp = ExtensionExists("GL_ARB_depth_clamp", gGLHExts.mSysExts);
 #if !LL_DARWIN
         mHasPointParameters = !mIsATI && ExtensionExists("GL_ARB_point_parameters", gGLHExts.mSysExts);
 #endif
@@ -634,6 +640,7 @@ void LLGLManager::initExtensions()
                 mHasFramebufferObject = FALSE;
                 mHasFramebufferMultisample = FALSE;
                 mHasDrawBuffers = FALSE;
+                mHasDepthClamp = FALSE;
                 mHasMipMapGeneration = FALSE;
                 mHasSeparateSpecularColor = FALSE;
                 mHasAnisotropic = FALSE;
@@ -685,10 +692,11 @@ void LLGLManager::initExtensions()
                 if (strchr(blacklist,'q')) mHasFramebufferObject = FALSE;//S
                 if (strchr(blacklist,'r')) mHasDrawBuffers = FALSE;//S
                 if (strchr(blacklist,'s')) mHasFramebufferMultisample = FALSE;
+                if (strchr(blacklist,'t')) mHasDepthClamp = FALSE;
 
         }
 #endif // LL_LINUX || LL_SOLARIS
-        
+
         if (!mHasMultitexture)
         {
                 LL_INFOS("RenderInit") << "Couldn't initialize multitexturing" << LL_ENDL;
@@ -1773,7 +1781,7 @@ LLGLDepthTest::~LLGLDepthTest()
         }
 }
 
-LLGLClampToFarClip::LLGLClampToFarClip(glh::matrix4f P)
+LLGLSquashToFarClip::LLGLSquashToFarClip(glh::matrix4f P)
 {
         for (U32 i = 0; i < 4; i++)
         {
@@ -1786,7 +1794,7 @@ LLGLClampToFarClip::LLGLClampToFarClip(glh::matrix4f P)
         glMatrixMode(GL_MODELVIEW);
 }
 
-LLGLClampToFarClip::~LLGLClampToFarClip()
+LLGLSquashToFarClip::~LLGLSquashToFarClip()
 {
         glMatrixMode(GL_PROJECTION);
         glPopMatrix();
diff --git a/linden/indra/llrender/llgl.h b/linden/indra/llrender/llgl.h
index 00ff1e2..cc7ebff 100644
--- a/linden/indra/llrender/llgl.h
+++ b/linden/indra/llrender/llgl.h
@@ -88,6 +88,7 @@ public:
         BOOL mHasOcclusionQuery;
         BOOL mHasPointParameters;
         BOOL mHasDrawBuffers;
+        BOOL mHasDepthClamp;
 
         // Other extensions.
         BOOL mHasAnisotropic;
@@ -306,11 +307,11 @@ private:
   leaves this class.
   Does not stack.
 */
-class LLGLClampToFarClip
+class LLGLSquashToFarClip
 {
 public:
-        LLGLClampToFarClip(glh::matrix4f projection);
-        ~LLGLClampToFarClip();
+        LLGLSquashToFarClip(glh::matrix4f projection);
+        ~LLGLSquashToFarClip();
 };
 
 /*
diff --git a/linden/indra/llrender/llglheaders.h b/linden/indra/llrender/llglheaders.h
index c7178a5..9e3ae9d 100644
--- a/linden/indra/llrender/llglheaders.h
+++ b/linden/indra/llrender/llglheaders.h
@@ -819,5 +819,15 @@ extern void glGetBufferPointervARB (GLenum, GLenum, GLvoid* *);
 
 #endif // LL_MESA / LL_WINDOWS / LL_DARWIN
 
+// Even when GL_ARB_depth_clamp is available in the driver, the (correct)
+// headers, and therefore GL_DEPTH_CLAMP might not be defined.
+// In that case GL_DEPTH_CLAMP_NV should be defined, but why not just
+// use the known numeric.
+//
+// To avoid #ifdef's in the code. Just define this here.
+#ifndef GL_DEPTH_CLAMP
+// Probably (still) called GL_DEPTH_CLAMP_NV.
+#define GL_DEPTH_CLAMP 0x864F
+#endif
 
 #endif // LL_LLGLHEADERS_H
diff --git a/linden/indra/newview/app_settings/settings.xml b/linden/indra/newview/app_settings/settings.xml
index bd4e05c..966b1af 100644
--- a/linden/indra/newview/app_settings/settings.xml
+++ b/linden/indra/newview/app_settings/settings.xml
@@ -9840,6 +9840,17 @@
       <key>Value</key>
       <integer>0</integer>
     </map>
+    <key>RenderWaterVoidCulling</key>
+    <map>
+      <key>Comment</key>
+      <string>Cull void water objects when off-screen.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>1</integer>
+    </map>
     <key>RotateRight</key>
     <map>
       <key>Comment</key>
diff --git a/linden/indra/newview/lldrawable.cpp b/linden/indra/newview/lldrawable.cpp
index 14aa38a..494ac5b 100644
--- a/linden/indra/newview/lldrawable.cpp
+++ b/linden/indra/newview/lldrawable.cpp
@@ -361,6 +361,8 @@ void LLDrawable::makeActive()
         {
                 U32 pcode = mVObjp->getPCode();
                 if (pcode == LLViewerObject::LL_VO_WATER ||
+                        pcode == LLViewerObject::LL_VO_HOLE_WATER ||
+                        pcode == LLViewerObject::LL_VO_EDGE_WATER ||
                         pcode == LLViewerObject::LL_VO_SURFACE_PATCH ||
                         pcode == LLViewerObject::LL_VO_PART_GROUP ||
                         pcode == LLViewerObject::LL_VO_HUD_PART_GROUP ||
diff --git a/linden/indra/newview/lldrawpool.cpp b/linden/indra/newview/lldrawpool.cpp
index e1bf1ed..3421731 100644
--- a/linden/indra/newview/lldrawpool.cpp
+++ b/linden/indra/newview/lldrawpool.cpp
@@ -95,6 +95,7 @@ LLDrawPool *LLDrawPool::createPool(const U32 type, LLViewerImage *tex0)
         case POOL_SKY:
                 poolp = new LLDrawPoolSky();
                 break;
+        case POOL_VOIDWATER:
         case POOL_WATER:
                 poolp = new LLDrawPoolWater();
                 break;
diff --git a/linden/indra/newview/lldrawpool.h b/linden/indra/newview/lldrawpool.h
index 87c3cca..f8c2ead 100644
--- a/linden/indra/newview/lldrawpool.h
+++ b/linden/indra/newview/lldrawpool.h
@@ -63,6 +63,7 @@ public:
                 POOL_BUMP,
                 POOL_INVISIBLE,
                 POOL_AVATAR,
+                POOL_VOIDWATER,
                 POOL_WATER,
                 POOL_GLOW,
                 POOL_ALPHA,
diff --git a/linden/indra/newview/lldrawpoolground.cpp b/linden/indra/newview/lldrawpoolground.cpp
index 889b494..c65524b 100644
--- a/linden/indra/newview/lldrawpoolground.cpp
+++ b/linden/indra/newview/lldrawpoolground.cpp
@@ -74,7 +74,7 @@ void LLDrawPoolGround::render(S32 pass)
 
         LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
 
-        LLGLClampToFarClip far_clip(glh_get_current_projection());
+        LLGLSquashToFarClip far_clip(glh_get_current_projection());
 
         F32 water_height = gAgent.getRegion()->getWaterHeight();
         glPushMatrix();
diff --git a/linden/indra/newview/lldrawpoolsky.cpp b/linden/indra/newview/lldrawpoolsky.cpp
index f0ed380..bed1030 100644
--- a/linden/indra/newview/lldrawpoolsky.cpp
+++ b/linden/indra/newview/lldrawpoolsky.cpp
@@ -101,7 +101,7 @@ void LLDrawPoolSky::render(S32 pass)
 
         LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
 
-        LLGLClampToFarClip far_clip(glh_get_current_projection());
+        LLGLSquashToFarClip far_clip(glh_get_current_projection());
 
         LLGLEnable fog_enable( (mVertexShaderLevel < 1 && LLViewerCamera::getInstance()->cameraUnderWater()) ? GL_FOG : 0);
 
diff --git a/linden/indra/newview/lldrawpoolwater.cpp b/linden/indra/newview/lldrawpoolwater.cpp
index ce3425d..81e1c68 100644
--- a/linden/indra/newview/lldrawpoolwater.cpp
+++ b/linden/indra/newview/lldrawpoolwater.cpp
@@ -523,6 +523,7 @@ void LLDrawPoolWater::shade()
         glColor4fv(water_color.mV);
 
         {
+                LLGLEnable depth_clamp(gGLManager.mHasDepthClamp ? GL_DEPTH_CLAMP : 0);
                 LLGLDisable cullface(GL_CULL_FACE);
                 for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
                         iter != mDrawFace.end(); iter++)
@@ -538,24 +539,20 @@ void LLDrawPoolWater::shade()
                         gGL.getTexUnit(diffTex)->bind(face->getTexture());
 
                         sNeedsReflectionUpdate = TRUE;
-                        
-                        if (water->getUseTexture())
+
+                        if (water->getUseTexture() || !water->isEdgeWater())
                         {
                                 sNeedsDistortionUpdate = TRUE;
                                 face->renderIndexed();
                         }
+                        else if (gGLManager.mHasDepthClamp)
+                        {
+                                face->renderIndexed();
+                        }
                         else
-                        { //smash background faces to far clip plane
-                                if (water->getIsEdgePatch())
-                                {
-                                        LLGLClampToFarClip far_clip(glh_get_current_projection());
-                                        face->renderIndexed();
-                                }
-                                else
-                                {
-                                        sNeedsDistortionUpdate = TRUE;
-                                        face->renderIndexed();
-                                }
+                        {
+                                LLGLSquashToFarClip far_clip(glh_get_current_projection());
+                                face->renderIndexed();
                         }
                 }
         }
diff --git a/linden/indra/newview/lldrawpoolwlsky.cpp b/linden/indra/newview/lldrawpoolwlsky.cpp
index 6ff65c7..451d08e 100644
--- a/linden/indra/newview/lldrawpoolwlsky.cpp
+++ b/linden/indra/newview/lldrawpoolwlsky.cpp
@@ -269,7 +269,7 @@ void LLDrawPoolWLSky::render(S32 pass)
         LLGLDepthTest depth(GL_TRUE, GL_FALSE);
         LLGLDisable clip(GL_CLIP_PLANE0);
 
-        LLGLClampToFarClip far_clip(glh_get_current_projection());
+        LLGLSquashToFarClip far_clip(glh_get_current_projection());
 
         renderSkyHaze(camHeightLocal);
 
diff --git a/linden/indra/newview/llfloatergodtools.cpp b/linden/indra/newview/llfloatergodtools.cpp
index 2bbbc65..461dfe2 100644
--- a/linden/indra/newview/llfloatergodtools.cpp
+++ b/linden/indra/newview/llfloatergodtools.cpp
@@ -252,13 +252,6 @@ void LLFloaterGodTools::onTabChanged(void* data, bool from_click)
 // static
 void LLFloaterGodTools::processRegionInfo(LLMessageSystem* msg)
 {
-        LLHost host = msg->getSender();
-        if (host != gAgent.getRegionHost())
-        {
-                // update is for a different region than the one we're in
-                return;
-        }
-
         //const S32 SIM_NAME_BUF = 256;
         U32 region_flags;
         U8 sim_access;
@@ -276,6 +269,8 @@ void LLFloaterGodTools::processRegionInfo(LLMessageSystem* msg)
         S32 redirect_grid_y;
         LLUUID cache_id;
 
+        LLHost host = msg->getSender();
+
         msg->getStringFast(_PREHASH_RegionInfo, _PREHASH_SimName, sim_name);
         msg->getU32Fast(_PREHASH_RegionInfo, _PREHASH_EstateID, estate_id);
         msg->getU32Fast(_PREHASH_RegionInfo, _PREHASH_ParentEstateID, parent_estate_id);
@@ -285,6 +280,15 @@ void LLFloaterGodTools::processRegionInfo(LLMessageSystem* msg)
         msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_ObjectBonusFactor, object_bonus_factor);
         msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_BillableFactor, billable_factor);
         msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_WaterHeight, water_height);
+
+        if (host != gAgent.getRegionHost())
+        {
+                // Update is for a different region than the one we're in.
+                // Just check for a waterheight change.
+                LLWorld::getInstance()->waterHeightRegionInfo(sim_name, water_height);
+                return;
+        }
+
         msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_TerrainRaiseLimit, terrain_raise_limit);
         msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_TerrainLowerLimit, terrain_lower_limit);
         msg->getS32Fast(_PREHASH_RegionInfo, _PREHASH_PricePerMeter, price_per_meter);
diff --git a/linden/indra/newview/llspatialpartition.cpp b/linden/indra/newview/llspatialpartition.cpp
index 31b537c..01ed375 100644
--- a/linden/indra/newview/llspatialpartition.cpp
+++ b/linden/indra/newview/llspatialpartition.cpp
@@ -1302,7 +1302,11 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
 {
         if (mSpatialPartition->isOcclusionEnabled() && LLPipeline::sUseOcclusion > 1)
         {
-                if (earlyFail(camera, this))
+                static LLCachedControl<BOOL> render_water_void_culling("RenderWaterVoidCulling", TRUE);
+                // Don't cull hole/edge water, unless RenderWaterVoidCulling is set and we have the GL_ARB_depth_clamp extension.
+                if ((mSpatialPartition->mDrawableType == LLPipeline::RENDER_TYPE_VOIDWATER &&
+                         !(render_water_void_culling && gGLManager.mHasDepthClamp)) ||
+                    earlyFail(camera, this))
                 {
                         setState(LLSpatialGroup::DISCARD_QUERY);
                         assert_states_valid(this);
@@ -1324,11 +1328,28 @@ void LLSpatialGroup::doOcclusion(LLCamera* camera)
                                         buildOcclusion();
                                 }
 
+                                // Depth clamp all water to avoid it being culled as a result of being
+                                // behind the far clip plane, and in the case of edge water to avoid
+                                // it being culled while still visible.
+                                bool const use_depth_clamp =
+                                        gGLManager.mHasDepthClamp &&
+                                        (mSpatialPartition->mDrawableType == LLPipeline::RENDER_TYPE_WATER ||
+                                         mSpatialPartition->mDrawableType == LLPipeline::RENDER_TYPE_VOIDWATER);
+                                if (use_depth_clamp)
+                                {
+                                        glEnable(GL_DEPTH_CLAMP);
+                                }
+
                                 glBeginQueryARB(GL_SAMPLES_PASSED_ARB, mOcclusionQuery);                                        
                                 glVertexPointer(3, GL_FLOAT, 0, mOcclusionVerts);
                                 glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8,
                                                         GL_UNSIGNED_BYTE, get_box_fan_indices(camera, mBounds[0]));
                                 glEndQueryARB(GL_SAMPLES_PASSED_ARB);
+
+                                if (use_depth_clamp)
+                                {
+                                        glDisable(GL_DEPTH_CLAMP);
+                                }
                         }
 
                         setState(LLSpatialGroup::QUERY_PENDING);
@@ -2280,9 +2301,11 @@ void renderBoundingBox(LLDrawable* drawable, BOOL set_color = TRUE)
                                                 gGL.color4f(0.5f,0.5f,0.5f,1.0f);
                                                 break;
                                 case LLViewerObject::LL_VO_PART_GROUP:
-                        case LLViewerObject::LL_VO_HUD_PART_GROUP:
+                                case LLViewerObject::LL_VO_HUD_PART_GROUP:
                                                 gGL.color4f(0,0,1,1);
                                                 break;
+                                case LLViewerObject::LL_VO_EDGE_WATER:
+                                case LLViewerObject::LL_VO_HOLE_WATER:
                                 case LLViewerObject::LL_VO_WATER:
                                                 gGL.color4f(0,0.5f,1,1);
                                                 break;
diff --git a/linden/indra/newview/llspatialpartition.h b/linden/indra/newview/llspatialpartition.h
index df96152..be0163b 100644
--- a/linden/indra/newview/llspatialpartition.h
+++ b/linden/indra/newview/llspatialpartition.h
@@ -481,7 +481,6 @@ private:
         drawinfo_list_t         mRenderMap[LLRenderPass::NUM_RENDER_TYPES];
 };
 
-
 //spatial partition for water (implemented in LLVOWater.cpp)
 class LLWaterPartition : public LLSpatialPartition
 {
@@ -491,6 +490,13 @@ public:
         virtual void addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32& index_count) { }
 };
 
+//spatial partition for hole and edge water (implemented in LLVOWater.cpp)
+class LLVoidWaterPartition : public LLWaterPartition
+{
+public:
+        LLVoidWaterPartition();
+};
+
 //spatial partition for terrain (impelmented in LLVOSurfacePatch.cpp)
 class LLTerrainPartition : public LLSpatialPartition
 {
diff --git a/linden/indra/newview/llsurface.cpp b/linden/indra/newview/llsurface.cpp
index a27f0e2..caaba05 100644
--- a/linden/indra/newview/llsurface.cpp
+++ b/linden/indra/newview/llsurface.cpp
@@ -1167,8 +1167,13 @@ void LLSurface::setWaterHeight(F32 height)
         if (!mWaterObjp.isNull())
         {
                 LLVector3 water_pos_region = mWaterObjp->getPositionRegion();
+                bool changed = water_pos_region.mV[VZ] != height;
                 water_pos_region.mV[VZ] = height;
                 mWaterObjp->setPositionRegion(water_pos_region);
+                if (changed)
+                {
+                        LLWorld::getInstance()->updateWaterObjects();
+                }
         }
         else
         {
diff --git a/linden/indra/newview/llviewerdisplay.cpp b/linden/indra/newview/llviewerdisplay.cpp
index ad186d5..5316337 100644
--- a/linden/indra/newview/llviewerdisplay.cpp
+++ b/linden/indra/newview/llviewerdisplay.cpp
@@ -602,7 +602,8 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot)
                 gFrameStats.start(LLFrameStats::UPDATE_CULL);
                 S32 water_clip = 0;
                 if ((LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_ENVIRONMENT) > 1) &&
-                         gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_WATER))
+                         (gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_WATER) ||
+                          gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_VOIDWATER)))
                 {
                         if (LLViewerCamera::getInstance()->cameraUnderWater())
                         {
diff --git a/linden/indra/newview/llviewerobject.cpp b/linden/indra/newview/llviewerobject.cpp
index a854583..f3353bb 100644
--- a/linden/indra/newview/llviewerobject.cpp
+++ b/linden/indra/newview/llviewerobject.cpp
@@ -144,6 +144,9 @@ LLViewerObject *LLViewerObject::createObject(const LLUUID &id, const LLPCode pco
           res = new LLVOSurfacePatch(id, pcode, regionp); break;
         case LL_VO_SKY:
           res = new LLVOSky(id, pcode, regionp); break;
+        case LL_VO_EDGE_WATER:
+        case LL_VO_HOLE_WATER:
+          res = new LLVOVoidWater(id, pcode, regionp); break;
         case LL_VO_WATER:
           res = new LLVOWater(id, pcode, regionp); break;
         case LL_VO_GROUND:
diff --git a/linden/indra/newview/llviewerobject.h b/linden/indra/newview/llviewerobject.h
index 7f8bd63..c443441 100644
--- a/linden/indra/newview/llviewerobject.h
+++ b/linden/indra/newview/llviewerobject.h
@@ -506,15 +506,16 @@ public:
         {
                 LL_VO_CLOUDS =                          LL_PCODE_APP | 0x20,
                 LL_VO_SURFACE_PATCH =           LL_PCODE_APP | 0x30,
-                //LL_VO_STARS =                         LL_PCODE_APP | 0x40,
+                LL_VO_WL_SKY =                          LL_PCODE_APP | 0x40,
                 LL_VO_SQUARE_TORUS =            LL_PCODE_APP | 0x50,
                 LL_VO_SKY =                                     LL_PCODE_APP | 0x60,
-                LL_VO_WATER =                           LL_PCODE_APP | 0x70,
-                LL_VO_GROUND =                          LL_PCODE_APP | 0x80,
-                LL_VO_PART_GROUP =                      LL_PCODE_APP | 0x90,
-                LL_VO_TRIANGLE_TORUS =          LL_PCODE_APP | 0xa0,
-                LL_VO_WL_SKY =                          LL_PCODE_APP | 0xb0, // should this be moved to 0x40?
-                LL_VO_HUD_PART_GROUP =          LL_PCODE_APP | 0xc0,
+                LL_VO_EDGE_WATER =                      LL_PCODE_APP | 0x70,
+                LL_VO_HOLE_WATER =                      LL_PCODE_APP | 0x80,
+                LL_VO_WATER =                           LL_PCODE_APP | 0x90,
+                LL_VO_GROUND =                          LL_PCODE_APP | 0xa0,
+                LL_VO_PART_GROUP =                      LL_PCODE_APP | 0xb0,
+                LL_VO_TRIANGLE_TORUS =          LL_PCODE_APP | 0xc0,
+                LL_VO_HUD_PART_GROUP =          LL_PCODE_APP | 0xd0,
         } EVOType;
 
         LLUUID                  mID;
@@ -713,8 +714,8 @@ public:
 class LLStaticViewerObject : public LLViewerObject
 {
 public:
-        LLStaticViewerObject(const LLUUID& id, const LLPCode type, LLViewerRegion* regionp, BOOL is_global = FALSE)
-                : LLViewerObject(id,type,regionp, is_global)
+        LLStaticViewerObject(const LLUUID& id, const LLPCode pcode, LLViewerRegion* regionp, BOOL is_global = FALSE)
+                : LLViewerObject(id, pcode, regionp, is_global)
         { }
 
         virtual void updateDrawable(BOOL force_damped);
diff --git a/linden/indra/newview/llviewerregion.cpp b/linden/indra/newview/llviewerregion.cpp
index 4257f70..4fd3bfb 100644
--- a/linden/indra/newview/llviewerregion.cpp
+++ b/linden/indra/newview/llviewerregion.cpp
@@ -215,6 +215,7 @@ LLViewerRegion::LLViewerRegion(const U64 &handle,
         //MUST MATCH declaration of eObjectPartitions
         mObjectPartition.push_back(new LLHUDPartition());               //PARTITION_HUD
         mObjectPartition.push_back(new LLTerrainPartition());   //PARTITION_TERRAIN
+        mObjectPartition.push_back(new LLVoidWaterPartition());         //PARTITION_VOIDWATER
         mObjectPartition.push_back(new LLWaterPartition());             //PARTITION_WATER
         mObjectPartition.push_back(new LLTreePartition());              //PARTITION_TREE
         mObjectPartition.push_back(new LLParticlePartition());  //PARTITION_PARTICLE
diff --git a/linden/indra/newview/llviewerregion.h b/linden/indra/newview/llviewerregion.h
index b0a98a9..09280a5 100644
--- a/linden/indra/newview/llviewerregion.h
+++ b/linden/indra/newview/llviewerregion.h
@@ -75,6 +75,7 @@ public:
         {
                 PARTITION_HUD=0,
                 PARTITION_TERRAIN,
+                PARTITION_VOIDWATER,
                 PARTITION_WATER,
                 PARTITION_TREE,
                 PARTITION_PARTICLE,
diff --git a/linden/indra/newview/llviewerwindow.cpp b/linden/indra/newview/llviewerwindow.cpp
index eb8977c..43a0d19 100644
--- a/linden/indra/newview/llviewerwindow.cpp
+++ b/linden/indra/newview/llviewerwindow.cpp
@@ -1303,6 +1303,11 @@ LLViewerWindow::LLViewerWindow(
                 gSavedSettings.setBOOL("ProbeHardwareOnStartup", FALSE);
         }
 
+        if (!gGLManager.mHasDepthClamp)
+        {
+        LL_INFOS("RenderInit") << "Missing feature GL_ARB_depth_clamp. Void water might disappear in rare cases." << LL_ENDL;
+        }
+
         // If we crashed while initializng GL stuff last time, disable certain features
         if (gSavedSettings.getBOOL("RenderInitError"))
         {
diff --git a/linden/indra/newview/llvosurfacepatch.cpp b/linden/indra/newview/llvosurfacepatch.cpp
index d86f758..1671880 100644
--- a/linden/indra/newview/llvosurfacepatch.cpp
+++ b/linden/indra/newview/llvosurfacepatch.cpp
@@ -86,7 +86,7 @@ public:
 //============================================================================
 
 LLVOSurfacePatch::LLVOSurfacePatch(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
-        :       LLStaticViewerObject(id, LL_VO_SURFACE_PATCH, regionp),
+        :       LLStaticViewerObject(id, pcode, regionp),
                 mDirtiedPatch(FALSE),
                 mPool(NULL),
                 mBaseComp(0),
diff --git a/linden/indra/newview/llvowater.cpp b/linden/indra/newview/llvowater.cpp
index 5b6a949..7e9470a 100644
--- a/linden/indra/newview/llvowater.cpp
+++ b/linden/indra/newview/llvowater.cpp
@@ -70,17 +70,16 @@ const F32 WAVE_STEP_INV	= (1. / WAVE_STEP);
 
 
 LLVOWater::LLVOWater(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
-:       LLStaticViewerObject(id, LL_VO_WATER, regionp)
+:       LLStaticViewerObject(id, pcode, regionp)
 {
         // Terrain must draw during selection passes so it can block objects behind it.
         mbCanSelect = FALSE;
         setScale(LLVector3(256.f, 256.f, 0.f)); // Hack for setting scale for bounding boxes/visibility.
 
         mUseTexture = TRUE;
-        mIsEdgePatch = FALSE;
+        mRenderType = LLPipeline::RENDER_TYPE_WATER;
 }
 
-
 void LLVOWater::markDead()
 {
         LLViewerObject::markDead();
@@ -123,7 +122,7 @@ LLDrawable *LLVOWater::createDrawable(LLPipeline *pipeline)
 {
         pipeline->allocDrawable(this);
         mDrawable->setLit(FALSE);
-        mDrawable->setRenderType(LLPipeline::RENDER_TYPE_WATER);
+        mDrawable->setRenderType(mRenderType);
 
         LLDrawPoolWater *pool = (LLDrawPoolWater*) gPipeline.getPool(LLDrawPool::POOL_WATER);
 
@@ -254,11 +253,6 @@ void LLVOWater::setUseTexture(const BOOL use_texture)
         mUseTexture = use_texture;
 }
 
-void LLVOWater::setIsEdgePatch(const BOOL edge_patch)
-{
-        mIsEdgePatch = edge_patch;
-}
-
 void LLVOWater::updateSpatialExtents(LLVector3 &newMin, LLVector3& newMax)
 {
         LLVector3 pos = getPositionAgent();
@@ -271,8 +265,13 @@ void LLVOWater::updateSpatialExtents(LLVector3 &newMin, LLVector3& newMax)
 }
 
 U32 LLVOWater::getPartitionType() const
-{ 
-        return LLViewerRegion::PARTITION_WATER; 
+{
+        return LLViewerRegion::PARTITION_WATER;
+}
+
+U32 LLVOVoidWater::getPartitionType() const
+{
+        return LLViewerRegion::PARTITION_VOIDWATER;
 }
 
 LLWaterPartition::LLWaterPartition()
@@ -283,3 +282,9 @@ LLWaterPartition::LLWaterPartition()
         mDrawableType = LLPipeline::RENDER_TYPE_WATER;
         mPartitionType = LLViewerRegion::PARTITION_WATER;
 }
+
+LLVoidWaterPartition::LLVoidWaterPartition()
+{
+        mDrawableType = LLPipeline::RENDER_TYPE_VOIDWATER;
+        mPartitionType = LLViewerRegion::PARTITION_VOIDWATER;
+}
diff --git a/linden/indra/newview/llvowater.h b/linden/indra/newview/llvowater.h
index 9c33e74..37480b6 100644
--- a/linden/indra/newview/llvowater.h
+++ b/linden/indra/newview/llvowater.h
@@ -35,6 +35,7 @@
 
 #include "llviewerobject.h"
 #include "llviewerimage.h"
+#include "pipeline.h"
 #include "v2math.h"
 
 const U32 N_RES = 16; //32                      // number of subdivisions of wave tile
@@ -71,18 +72,29 @@ public:
         /*virtual*/ void updateTextures();
         /*virtual*/ void setPixelAreaAndAngle(LLAgent &agent); // generate accurate apparent angle and area
 
-        virtual U32 getPartitionType() const;
+        /*virtual*/ U32 getPartitionType() const;
 
         /*virtual*/ BOOL isActive() const; // Whether this object needs to do an idleUpdate.
 
         void setUseTexture(const BOOL use_texture);
-        void setIsEdgePatch(const BOOL edge_patch);
         BOOL getUseTexture() const { return mUseTexture; }
-        BOOL getIsEdgePatch() const { return mIsEdgePatch; }
+
+        bool isEdgeWater(void) const { return mPrimitiveCode == LL_VO_EDGE_WATER; }
 
 protected:
         BOOL mUseTexture;
-        BOOL mIsEdgePatch;
+        LLPipeline::LLRenderTypeMask mRenderType;
+};
+
+class LLVOVoidWater : public LLVOWater
+{
+public:
+        LLVOVoidWater(LLUUID const& id, LLPCode pcode, LLViewerRegion* regionp) : LLVOWater(id, pcode, regionp)
+        {
+                mRenderType = LLPipeline::RENDER_TYPE_VOIDWATER;
+        }
+
+        /*virtual*/ U32 getPartitionType() const;
 };
 
 #endif // LL_VOSURFACEPATCH_H
diff --git a/linden/indra/newview/llworld.cpp b/linden/indra/newview/llworld.cpp
index 90ab49b..5026808 100644
--- a/linden/indra/newview/llworld.cpp
+++ b/linden/indra/newview/llworld.cpp
@@ -61,6 +61,12 @@
 #include "llappviewer.h"                // for do_disconnect()
 
 #include "hippoLimits.h"
+
+#include <deque>
+#include <queue>
+#include <map>
+#include <cstring>
+
 //
 // Globals
 //
@@ -810,10 +816,69 @@ F32 LLWorld::getLandFarClip() const
 
 void LLWorld::setLandFarClip(const F32 far_clip)
 {
+        static S32 const rwidth = (S32)REGION_WIDTH_U32;
+        S32 const n1 = (llceil(mLandFarClip) - 1) / rwidth;
+        S32 const n2 = (llceil(far_clip) - 1) / rwidth;
+        bool need_water_objects_update = n1 != n2;
+
         mLandFarClip = far_clip;
+
+        if (need_water_objects_update)
+        {
+                updateWaterObjects();
+        }
 }
 
+// Some region that we're connected to, but not the one we're in, gave us
+// a (possibly) new water height. Update it in our local copy.
+void LLWorld::waterHeightRegionInfo(std::string const& sim_name, F32 water_height)
+{
+        for (region_list_t::iterator iter = mRegionList.begin(); iter != mRegionList.end(); ++iter)
+        {
+                if ((*iter)->getName() == sim_name)
+                {
+                        (*iter)->setWaterHeight(water_height);
+                        break;
+                }
+        }
+}
 
+// There are three types of water objects:
+// Region water objects: the water in a region.
+// Hole water objects: water in the void but within current draw distance.
+// Edge water objects: the water outside the draw distance, up till the horizon.
+//
+// For example:
+//
+// -----------------------horizon-------------------------
+// |                 |                 |                 |
+// |  Edge Water     |                 |                 |
+// |                 |                 |                 |
+// |                 |                 |                 |
+// |                 |                 |                 |
+// |                 |                 |                 |
+// |                 |      rwidth     |                 |
+// |                 |     <----->     |                 |
+// -------------------------------------------------------
+// |                 |Hole |other|     |                 |
+// |                 |Water|reg. |     |                 |
+// |                 |-----------------|                 |
+// |                 |other|cur. |<--> |                 |
+// |                 |reg. | reg.|  \__|_ draw distance  |
+// |                 |-----------------|                 |
+// |                 |     |     |<--->|                 |
+// |                 |     |     |  \__|_ range          |
+// -------------------------------------------------------
+// |                 |<----width------>|<--horizon ext.->|
+// |                 |                 |                 |
+// |                 |                 |                 |
+// |                 |                 |                 |
+// |                 |                 |                 |
+// |                 |                 |                 |
+// |                 |                 |                 |
+// |                 |                 |                 |
+// -------------------------------------------------------
+//
 void LLWorld::updateWaterObjects()
 {
         if (!gAgent.getRegion())
@@ -826,128 +891,264 @@ void LLWorld::updateWaterObjects()
                 return;
         }
 
-        // First, determine the min and max "box" of water objects
-        S32 min_x = 0;
-        S32 min_y = 0;
-        S32 max_x = 0;
-        S32 max_y = 0;
+        // Region width in meters.
+        S32 const rwidth = (S32)REGION_WIDTH_U32;
+
+        // The distance we might see into the void
+        // when standing on the edge of a region, in meters.
+        S32 const draw_distance = llceil(mLandFarClip);
+
+        // We can only have "holes" in the water (where there no region) if we
+        // can have existing regions around it. Taking into account that this
+        // code is only executed when we enter a region, and not when we walk
+        // around in it, we (only) need to take into account regions that fall
+        // within the draw_distance.
+        //
+        // Set 'range' to draw_distance, rounded up to the nearest multiple of rwidth.
+        S32 const nsims = (draw_distance + rwidth - 1) / rwidth;
+        S32 const range = nsims * rwidth;
+
+        // Get South-West corner of current region.
+        LLViewerRegion const* regionp = gAgent.getRegion();
         U32 region_x, region_y;
-
-        S32 rwidth = 256;
-
-        // We only want to fill in water for stuff that's near us, say, within 256 or 512m
-        S32 range = LLViewerCamera::getInstance()->getFar() > 256.f ? 512 : 256;
-
-        LLViewerRegion* regionp = gAgent.getRegion();
         from_region_handle(regionp->getHandle(), &region_x, &region_y);
 
-        min_x = (S32)region_x - range;
-        min_y = (S32)region_y - range;
-        max_x = (S32)region_x + range;
-        max_y = (S32)region_y + range;
+        // The min. and max. coordinates of the South-West corners of the Hole water objects.
+        S32 const min_x = (S32)region_x - range;
+        S32 const min_y = (S32)region_y - range;
+        S32 const max_x = (S32)region_x + range;
+        S32 const max_y = (S32)region_y + range;
+
+        // Attempt to determine a sensible water height for all the
+        // Hole Water objects.
+        //
+        // It make little sense to try to guess what the best water
+        // height should be when that isn't completely obvious: if it's
+        // impossible to satisfy every region's water height without
+        // getting a jump in the water height.
+        //
+        // In order to keep the reasoning simple, we assume something
+        // logical as a group of connected regions, where the coastline
+        // is at the outer edge. Anything more complex that would "break"
+        // under such an assumption would probably break anyway (would
+        // depend on terrain editing and existing mega prims, say, if
+        // anything would make sense at all).
+        //
+        // So, what we do is find all connected regions within the
+        // draw distance that border void, and then pick the lowest
+        // water height of those (coast) regions.
+        S32 const n = 2 * nsims + 1;
+        S32 const origin = nsims + nsims * n;
+        std::vector<F32> water_heights(n * n);
+        std::vector<U8> checked(n * n, 0);              // index = nx + ny * n + origin;
+        U8 const region_bit = 1;
+        U8 const hole_bit = 2;
+        U8 const bordering_hole_bit = 4;
+        U8 const bordering_edge_bit = 8;
+        // Use the legacy waterheight for the Edge water in the case
+        // that we don't find any Hole water at all.
+        F32 water_height = DEFAULT_WATER_HEIGHT;
+        int max_count = 0;
+        LL_DEBUGS("WaterHeight") << "Current region: " << regionp->getName() << "; water height: " << regionp->getWaterHeight() << " m." << LL_ENDL;
+        std::map<S32, int> water_height_counts;
+        typedef std::queue<std::pair<S32, S32>, std::deque<std::pair<S32, S32> > > nxny_pairs_type;
+        nxny_pairs_type nxny_pairs;
+        nxny_pairs.push(nxny_pairs_type::value_type(0, 0));
+        water_heights[origin] = regionp->getWaterHeight();
+        checked[origin] = region_bit;
+        // For debugging purposes.
+        int number_of_connected_regions = 1;
+        int uninitialized_regions = 0;
+        int bordering_hole = 0;
+        int bordering_edge = 0;
+        while(!nxny_pairs.empty())
+        {
+                S32 const nx = nxny_pairs.front().first;
+                S32 const ny = nxny_pairs.front().second;
+                LL_DEBUGS("WaterHeight") << "nx,ny = " << nx << "," << ny << LL_ENDL;
+                S32 const index = nx + ny * n + origin;
+                nxny_pairs.pop();
+                for (S32 dir = 0; dir < 4; ++dir)
+                {
+                        S32 const cnx = nx + gDirAxes[dir][0];
+                        S32 const cny = ny + gDirAxes[dir][1];
+                        LL_DEBUGS("WaterHeight") << "dir = " << dir << "; cnx,cny = " << cnx << "," << cny << LL_ENDL;
+                        S32 const cindex = cnx + cny * n + origin;
+                        bool is_hole = false;
+                        bool is_edge = false;
+                        LLViewerRegion* new_region_found = NULL;
+                        if (cnx < -nsims || cnx > nsims ||
+                            cny < -nsims || cny > nsims)
+                        {
+                                LL_DEBUGS("WaterHeight") << "  Edge Water!" << LL_ENDL;
+                                // Bumped into Edge water object.
+                                is_edge = true;
+                        }
+                        else if (checked[cindex])
+                        {
+                                LL_DEBUGS("WaterHeight") << "  Already checked before!" << LL_ENDL;
+                                // Already checked.
+                                is_hole = (checked[cindex] & hole_bit);
+                        }
+                        else
+                        {
+                                S32 x = (S32)region_x + cnx * rwidth;
+                                S32 y = (S32)region_y + cny * rwidth;
+                                U64 region_handle = to_region_handle(x, y);
+                                new_region_found = getRegionFromHandle(region_handle);
+                                is_hole = !new_region_found;
+                                checked[cindex] = is_hole ? hole_bit : region_bit;
+                        }
+                        if (is_hole)
+                        {
+                                // This was a region that borders at least one 'hole'.
+                                // Count the found coastline.
+                                F32 new_water_height = water_heights[index];
+                                LL_DEBUGS("WaterHeight") << "  This is void; counting coastline with water height of " << new_water_height << LL_ENDL;
+                                S32 new_water_height_cm = llround(new_water_height * 100);
+                                int count = (water_height_counts[new_water_height_cm] += 1);
+                                // Just use the lowest water height: this is mainly about the horizon water,
+                                // and whatever we do, we don't want it to be possible to look under the water
+                                // when looking in the distance: it is better to make a step downwards in water
+                                // height when going away from the avie than a step upwards. However, since
+                                // everyone is used to DEFAULT_WATER_HEIGHT, don't allow a single region
+                                // to drag the water level below DEFAULT_WATER_HEIGHT on it's own.
+                                if (bordering_hole == 0 ||                      // First time we get here.
+                                    (new_water_height >= DEFAULT_WATER_HEIGHT &&
+                                         new_water_height < water_height) ||
+                                    (new_water_height < DEFAULT_WATER_HEIGHT &&
+                                         count > max_count)
+                                   )
+                                {
+                                        water_height = new_water_height;
+                                }
+                                if (count > max_count)
+                                {
+                                        max_count = count;
+                                }
+                                if (!(checked[index] & bordering_hole_bit))
+                                {
+                                        checked[index] |= bordering_hole_bit;
+                                        ++bordering_hole;
+                                }
+                        }
+                        else if (is_edge && !(checked[index] & bordering_edge_bit))
+                        {
+                                checked[index] |= bordering_edge_bit;
+                                ++bordering_edge;
+                        }
+                        if (!new_region_found)
+                        {
+                                // Dead end, there is no region here.
+                                continue;
+                        }
+                        // Found a new connected region.
+                        ++number_of_connected_regions;
+                        if (new_region_found->getName().empty())
+                        {
+                                // Uninitialized LLViewerRegion, don't use it's water height.
+                                LL_DEBUGS("WaterHeight") << "  Uninitialized region." << LL_ENDL;
+                                ++uninitialized_regions;
+                                continue;
+                        }
+                        nxny_pairs.push(nxny_pairs_type::value_type(cnx, cny));
+                        water_heights[cindex] = new_region_found->getWaterHeight();
+                        LL_DEBUGS("WaterHeight") << "  Found a new region (name: " << new_region_found->getName() << "; water height: " << water_heights[cindex] << " m)!" << LL_ENDL;
+                }
+        }
+        llinfos << "Number of connected regions: " << number_of_connected_regions << " (" << uninitialized_regions <<
+                " uninitialized); number of regions bordering Hole water: " << bordering_hole <<
+                "; number of regions bordering Edge water: " << bordering_edge << llendl;
+        llinfos << "Coastline count (height, count): ";
+        bool first = true;
+        for (std::map<S32, int>::iterator iter = water_height_counts.begin(); iter != water_height_counts.end(); ++iter)
+        {
+                if (!first) llcont << ", ";
+                llcont << "(" << (iter->first / 100.f) << ", " << iter->second << ")";
+                first = false;
+        }
+        llcont << llendl;
+        llinfos << "Water height used for Hole and Edge water objects: " << water_height << llendl;
 
-        F32 height = 0.f;
-        
-        for (region_list_t::iterator iter = mRegionList.begin();
-                 iter != mRegionList.end(); ++iter)
+        // Update all Region water objects.
+        for (region_list_t::iterator iter = mRegionList.begin(); iter != mRegionList.end(); ++iter)
         {
                 LLViewerRegion* regionp = *iter;
                 LLVOWater* waterp = regionp->getLand().getWaterObj();
-                height += regionp->getWaterHeight();
                 if (waterp)
                 {
                         gObjectList.updateActive(waterp);
                 }
         }
 
+        // Clean up all existing Hole water objects.
         for (std::list<LLVOWater*>::iterator iter = mHoleWaterObjects.begin();
-                 iter != mHoleWaterObjects.end(); ++ iter)
+                 iter != mHoleWaterObjects.end(); ++iter)
         {
                 LLVOWater* waterp = *iter;
                 gObjectList.killObject(waterp);
         }
         mHoleWaterObjects.clear();
 
-        // Now, get a list of the holes
-        S32 x, y;
-        for (x = min_x; x <= max_x; x += rwidth)
+        // Let the Edge and Hole water boxes be 1024 meter high so that they
+        // are never too small to be drawn (A LL_VO_*_WATER box has water
+        // rendered on it's bottom surface only), and put their bottom at
+        // the current regions water height.
+        F32 const box_height = 1024;
+        F32 const water_center_z = water_height + box_height / 2;
+
+        // Create new Hole water objects within 'range' where there is no region.
+        for (S32 x = min_x; x <= max_x; x += rwidth)
         {
-                for (y = min_y; y <= max_y; y += rwidth)
+                for (S32 y = min_y; y <= max_y; y += rwidth)
                 {
                         U64 region_handle = to_region_handle(x, y);
                         if (!getRegionFromHandle(region_handle))
                         {
-                                LLVOWater* waterp = (LLVOWater *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_WATER, gAgent.getRegion());
+                                LLVOWater* waterp = (LLVOWater*)gObjectList.createObjectViewer(LLViewerObject::LL_VO_HOLE_WATER, gAgent.getRegion());
                                 waterp->setUseTexture(FALSE);
-                                waterp->setPositionGlobal(LLVector3d(x + rwidth/2,
-                                                                                                         y + rwidth/2,
-                                                                                                         256.f+DEFAULT_WATER_HEIGHT));
-                                waterp->setScale(LLVector3((F32)rwidth, (F32)rwidth, 512.f));
+                                waterp->setPositionGlobal(LLVector3d(x + rwidth / 2, y + rwidth / 2, water_center_z));
+                                waterp->setScale(LLVector3((F32)rwidth, (F32)rwidth, box_height));
                                 gPipeline.createObject(waterp);
                                 mHoleWaterObjects.push_back(waterp);
                         }
                 }
         }
 
-        // Update edge water objects
-        S32 wx, wy;
-        S32 center_x, center_y;
-        wx = (max_x - min_x) + rwidth;
-        wy = (max_y - min_y) + rwidth;
-        center_x = min_x + (wx >> 1);
-        center_y = min_y + (wy >> 1);
-
-        S32 add_boundary[4] = {
-                512 - (max_x - region_x),
-                512 - (max_y - region_y),
-                512 - (region_x - min_x),
-                512 - (region_y - min_y) };
-                
-        S32 dir;
-        for (dir = 0; dir < 8; dir++)
+        // Center of the region.
+        S32 const center_x = region_x + rwidth / 2;
+        S32 const center_y = region_y + rwidth / 2;
+        // Width of the area with Hole water objects.
+        S32 const width = rwidth + 2 * range;
+        S32 const horizon_extend = 2048 + 512 - range;  // Legacy value.
+        // The overlap is needed to get rid of sky pixels being visible between the
+        // Edge and Hole water object at greater distances (due to floating point
+        // round off errors).
+        S32 const edge_hole_overlap = 1;                // Twice the actual overlap.
+
+        for (S32 dir = 0; dir < 8; ++dir)
         {
-                S32 dim[2] = { 0 };
-                switch (gDirAxes[dir][0])
-                {
-                case -1: dim[0] = add_boundary[2]; break;
-                case  0: dim[0] = wx; break;
-                default: dim[0] = add_boundary[0]; break;
-                }
-                switch (gDirAxes[dir][1])
-                {
-                case -1: dim[1] = add_boundary[3]; break;
-                case  0: dim[1] = wy; break;
-                default: dim[1] = add_boundary[1]; break;
-                }
+                // Size of the Edge water objects.
+                S32 const dim_x = (gDirAxes[dir][0] == 0) ? width : (horizon_extend + edge_hole_overlap);
+                S32 const dim_y = (gDirAxes[dir][1] == 0) ? width : (horizon_extend + edge_hole_overlap);
+                // And their position.
+                S32 const water_center_x = center_x + (width + horizon_extend) / 2 * gDirAxes[dir][0];
+                S32 const water_center_y = center_y + (width + horizon_extend) / 2 * gDirAxes[dir][1];
 
-                // Resize and reshape the water objects
-                const S32 water_center_x = center_x + llround((wx + dim[0]) * 0.5f * gDirAxes[dir][0]);
-                const S32 water_center_y = center_y + llround((wy + dim[1]) * 0.5f * gDirAxes[dir][1]);
-                
                 LLVOWater* waterp = mEdgeWaterObjects[dir];
                 if (!waterp || waterp->isDead())
                 {
                         // The edge water objects can be dead because they're attached to the region that the
                         // agent was in when they were originally created.
-                        mEdgeWaterObjects[dir] = (LLVOWater *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_WATER,
-                                                                                                                                                                 gAgent.getRegion());
+                        mEdgeWaterObjects[dir] = (LLVOWater *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_EDGE_WATER, gAgent.getRegion());
                         waterp = mEdgeWaterObjects[dir];
                         waterp->setUseTexture(FALSE);
-                        waterp->setIsEdgePatch(TRUE);
                         gPipeline.createObject(waterp);
                 }
 
                 waterp->setRegion(gAgent.getRegion());
-                LLVector3d water_pos(water_center_x, water_center_y, 
-                        DEFAULT_WATER_HEIGHT+256.f);
-                LLVector3 water_scale((F32) dim[0], (F32) dim[1], 512.f);
-
-                //stretch out to horizon
-                water_scale.mV[0] += fabsf(2048.f * gDirAxes[dir][0]);
-                water_scale.mV[1] += fabsf(2048.f * gDirAxes[dir][1]);
-
-                water_pos.mdV[0] += 1024.f * gDirAxes[dir][0];
-                water_pos.mdV[1] += 1024.f * gDirAxes[dir][1];
+                LLVector3d water_pos(water_center_x, water_center_y, water_center_z);
+                LLVector3 water_scale((F32) dim_x, (F32) dim_y, box_height);
 
                 waterp->setPositionGlobal(water_pos);
                 waterp->setScale(water_scale);
diff --git a/linden/indra/newview/llworld.h b/linden/indra/newview/llworld.h
index 46aefd9..2c5815c 100644
--- a/linden/indra/newview/llworld.h
+++ b/linden/indra/newview/llworld.h
@@ -142,6 +142,7 @@ public:
 
         LLViewerImage *getDefaultWaterTexture();
         void updateWaterObjects();
+        void waterHeightRegionInfo(std::string const& sim_name, F32 water_height);
         void shiftRegions(const LLVector3& offset);
 
         void setSpaceTimeUSec(const U64 space_time_usec);
diff --git a/linden/indra/newview/pipeline.cpp b/linden/indra/newview/pipeline.cpp
index f10aca5..e024e4c 100644
--- a/linden/indra/newview/pipeline.cpp
+++ b/linden/indra/newview/pipeline.cpp
@@ -1833,11 +1833,12 @@ void LLPipeline::markRebuild(LLDrawable *drawablep, LLDrawable::EDrawableFlags f
 void LLPipeline::stateSort(LLCamera& camera, LLCullResult &result)
 {
         const U32 face_mask = (1 << LLPipeline::RENDER_TYPE_AVATAR) |
-                                                  (1 << LLPipeline::RENDER_TYPE_GROUND) |
-                                                  (1 << LLPipeline::RENDER_TYPE_TERRAIN) |
-                                                  (1 << LLPipeline::RENDER_TYPE_TREE) |
-                                                  (1 << LLPipeline::RENDER_TYPE_SKY) |
-                                                  (1 << LLPipeline::RENDER_TYPE_WATER);
+                              (1 << LLPipeline::RENDER_TYPE_GROUND) |
+                              (1 << LLPipeline::RENDER_TYPE_TERRAIN) |
+                              (1 << LLPipeline::RENDER_TYPE_TREE) |
+                              (1 << LLPipeline::RENDER_TYPE_SKY) |
+                              (1 << LLPipeline::RENDER_TYPE_VOIDWATER) |
+                              (1 << LLPipeline::RENDER_TYPE_WATER);
 
         if (mRenderTypeMask & face_mask)
         {
@@ -4436,6 +4437,11 @@ void LLPipeline::toggleRenderType(U32 type)
 {
         U32 bit = (1<<type);
         gPipeline.mRenderTypeMask ^= bit;
+        if (type == RENDER_TYPE_WATER)
+        {
+                bit = (1 << RENDER_TYPE_VOIDWATER);
+                gPipeline.mRenderTypeMask ^= bit;
+        }
 }
 
 //static
@@ -5744,18 +5750,19 @@ void LLPipeline::renderDeferredLighting()
                 LLGLDisable stencil(GL_STENCIL_TEST);
 
                 U32 render_mask = mRenderTypeMask;
-                mRenderTypeMask =       mRenderTypeMask & 
-                                                        ((1 << LLPipeline::RENDER_TYPE_SKY) |
-                                                        (1 << LLPipeline::RENDER_TYPE_CLOUDS) |
-                                                        (1 << LLPipeline::RENDER_TYPE_WL_SKY) |
-                                                        (1 << LLPipeline::RENDER_TYPE_ALPHA) |
-                                                        (1 << LLPipeline::RENDER_TYPE_AVATAR) |
-                                                        (1 << LLPipeline::RENDER_TYPE_WATER) |
-                                                        (1 << LLPipeline::RENDER_TYPE_FULLBRIGHT) |
-                                                        (1 << LLPipeline::RENDER_TYPE_VOLUME) |
-                                                        (1 << LLPipeline::RENDER_TYPE_GLOW) |
-                                                        (1 << LLPipeline::RENDER_TYPE_BUMP));
-                
+                mRenderTypeMask = mRenderTypeMask &
+                                  ((1 << LLPipeline::RENDER_TYPE_SKY) |
+                                   (1 << LLPipeline::RENDER_TYPE_CLOUDS) |
+                                   (1 << LLPipeline::RENDER_TYPE_WL_SKY) |
+                                   (1 << LLPipeline::RENDER_TYPE_ALPHA) |
+                                   (1 << LLPipeline::RENDER_TYPE_AVATAR) |
+                                   (1 << LLPipeline::RENDER_TYPE_VOIDWATER) |
+                                   (1 << LLPipeline::RENDER_TYPE_WATER) |
+                                   (1 << LLPipeline::RENDER_TYPE_FULLBRIGHT) |
+                                   (1 << LLPipeline::RENDER_TYPE_VOLUME) |
+                                   (1 << LLPipeline::RENDER_TYPE_GLOW) |
+                                   (1 << LLPipeline::RENDER_TYPE_BUMP));
+
                 renderGeomPostDeferred(*LLViewerCamera::getInstance());
                 mRenderTypeMask = render_mask;
         }
@@ -5910,10 +5917,11 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
 
                         if (LLDrawPoolWater::sNeedsDistortionUpdate)
                         {
-                                mRenderTypeMask &=      ~((1<<LLPipeline::RENDER_TYPE_WATER) |
-                                                                          (1<<LLPipeline::RENDER_TYPE_GROUND) |
-                                                                          (1<<LLPipeline::RENDER_TYPE_SKY) |
-                                                                          (1<<LLPipeline::RENDER_TYPE_CLOUDS)); 
+                                mRenderTypeMask &= ~((1<<LLPipeline::RENDER_TYPE_WATER) |
+                                                     (1<<LLPipeline::RENDER_TYPE_VOIDWATER) |
+                                                     (1<<LLPipeline::RENDER_TYPE_GROUND) |
+                                                     (1<<LLPipeline::RENDER_TYPE_SKY) |
+                                                     (1<<LLPipeline::RENDER_TYPE_CLOUDS));
 
                                 if (gSavedSettings.getBOOL("RenderWaterReflections"))
                                 { //mask out selected geometry based on reflection detail
@@ -5955,8 +5963,9 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
                 if (last_update)
                 {
                         camera.setFar(camera_in.getFar());
-                        mRenderTypeMask = type_mask & (~(1<<LLPipeline::RENDER_TYPE_WATER) |
-                                                                                        (1<<LLPipeline::RENDER_TYPE_GROUND));   
+                        mRenderTypeMask = type_mask & ~((1<<LLPipeline::RENDER_TYPE_WATER) |
+                                                        (1<<LLPipeline::RENDER_TYPE_VOIDWATER) |
+                                                        (1<<LLPipeline::RENDER_TYPE_GROUND));
                         stop_glerror();
 
                         LLPipeline::sUnderWaterRender = LLViewerCamera::getInstance()->cameraUnderWater() ? FALSE : TRUE;
diff --git a/linden/indra/newview/pipeline.h b/linden/indra/newview/pipeline.h
index 1a32b30..3f3309a 100644
--- a/linden/indra/newview/pipeline.h
+++ b/linden/indra/newview/pipeline.h
@@ -314,8 +314,9 @@ public:
                 RENDER_TYPE_AVATAR              = LLDrawPool::POOL_AVATAR,
                 RENDER_TYPE_TREE                = LLDrawPool::POOL_TREE,
                 RENDER_TYPE_INVISIBLE   = LLDrawPool::POOL_INVISIBLE,
+                RENDER_TYPE_VOIDWATER   = LLDrawPool::POOL_VOIDWATER,
                 RENDER_TYPE_WATER               = LLDrawPool::POOL_WATER,
-                RENDER_TYPE_ALPHA               = LLDrawPool::POOL_ALPHA,
+                RENDER_TYPE_ALPHA               = LLDrawPool::POOL_ALPHA,
                 RENDER_TYPE_GLOW                = LLDrawPool::POOL_GLOW,
                 
                 // Following are object types (only used in drawable mRenderType)