Ticket #721: water_ro_r3_r9066.patch

source/renderer/PatchRData.h

@@ -41 +41 @@
     void RenderSides();
     void RenderPriorities();
 
+    void RenderFancyWater(GLint waterDepth);
+    void RenderSimpleWater();
+
     static void RenderBases(const std::vector<CPatchRData*>& patches);
     static void RenderBlends(const std::vector<CPatchRData*>& patches);
     static void RenderStreams(const std::vector<CPatchRData*>& patches, int streamflags);
@@ -126 +129 @@
 
     // splats used in blend pass
     std::vector<SSplat> m_BlendSplats;
+
+    // Simple water vertex description data structure
+    struct SSimpleWaterVertex {
+        // vertex position
+        CVector3D m_Position;
+        // vertex uvs for texture 0
+        float m_UVs[2];
+        // vertex 3d for texture 1 == vertex position so removed
+        // CVector3D m_PosTex1;
+        // Color TODO: Try to use packed colors? (here:floats)
+        RGBAColor m_Color;
+        // TODO: Add padding up to 64bytes? (for 32 bytes align)
+    };
+
+    // Fancy water vertex description data structure
+    struct SWaterVertex {
+        // vertex position
+        CVector3D m_Position;
+        // vertex uvs for normal map texture
+        float m_UVs[2];
+        // water depth (varying for shader)
+        float m_Depth;
+        // add some padding (TODO: Check)
+        u32 m_Padding[2];
+    };
+
+    void BuildSimpleWaterVertices();
+    void BuildFancyWaterVertices();
+
+    void BuildWaterVertexData(); // Common to simple and fancy water
+
+    // Water vertex buffer
+    CVertexBuffer::VBChunk* m_VBWater;
+
+    // Water indices into buffer
+    // NB: Indices are identical for fancy or regular water (same path)
+    void BuildWaterIndices();
+
+    // 256*256 seems to be enough
+    std::vector<unsigned short> m_WaterIndices;
+
+    // Build data for fancy water or reference data for
+    // computing simple water
+    std::vector<SWaterVertex> m_WaterVertexData;
+
+    // maximum and minimum depth of water at all vertices on the patch
+    // signed value: can be negative (if vertex emerges of water)
+    float max_wdepth;
+    float min_wdepth;
+    // Check if there is water on this patch (useful sometimes internally)
+    bool FullyEmerged();
+    bool EntirelyUnderWater();
+
 };
 
 #endif

source/renderer/TerrainRenderer.h

@@ -114 +114 @@
 
 private:
     TerrainRendererInternals* m;
+
+    /*
+     * RenderFancyWater: internal rendering method for fancy water
+     */
+    bool RenderFancyWater();
+    /*
+     * RenderSimpleWater: internal rendering method for water
+     */
+    void RenderSimpleWater();
 };
 
 #endif // INCLUDED_TERRAINRENDERER

source/renderer/PatchRData.cpp

@@ -56 +56 @@
 ///////////////////////////////////////////////////////////////////
 // CPatchRData constructor
 CPatchRData::CPatchRData(CPatch* patch) :
-    m_Patch(patch), m_VBSides(0), m_VBBase(0), m_VBBaseIndices(0), m_VBBlends(0), m_VBBlendIndices(0)
+    m_Patch(patch), m_VBSides(0), m_VBBase(0), m_VBBaseIndices(0), m_VBBlends(0), m_VBBlendIndices(0),
+    m_VBWater(0), max_wdepth(-FLT_MAX), min_wdepth(FLT_MAX)
 {
     debug_assert(patch);
     Build();
@@ -631 +632 @@
     BuildSides();
     BuildIndices();
     BuildBlends();
+
+    WaterManager* WaterMgr = g_Renderer.GetWaterManager();
+    if (WaterMgr->WillRenderFancyWater()) {
+        BuildFancyWaterVertices();
+    } else {
+        BuildSimpleWaterVertices();
+    }
+    BuildWaterIndices();
 }
 
 void CPatchRData::Update()
@@ -644 +653 @@
         BuildIndices();
         BuildBlends();
 
+        WaterManager* WaterMgr = g_Renderer.GetWaterManager();
+        if (WaterMgr->WillRenderFancyWater()) {
+            // TODO: Switch on fancy or not fancy water
+            BuildFancyWaterVertices();
+        } else {
+            BuildSimpleWaterVertices();
+        }
+
         m_UpdateFlags=0;
     }
 }
@@ -1048 +1065 @@
         }
     }
 }
+
+//
+// Water build and rendering
+//
+
+// Build vertex buffer for water vertices over our patch
+void CPatchRData::BuildWaterVertexData()
+{
+    // number of vertices in each direction in each patch
+    const ssize_t vsize=PATCH_SIZE+1;
+
+    m_WaterVertexData.resize(vsize*vsize);
+
+    // We need to use this to access the water manager or we may not have the
+    // actual values but some compiled-in defaults
+    CmpPtr<ICmpWaterManager> cmpWaterManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+
+    // TODO: This is not (yet) exported via the ICmp interface so... we stick to these values which can be compiled in defaults
+    WaterManager* WaterMgr = g_Renderer.GetWaterManager();
+    const float repeatPeriod = WaterMgr->m_RepeatPeriod;
+#if 0
+    // With non fancy water, period is a constant? TODO: Check
+    const float repeatPeriod = 16.0f;
+#endif
+
+
+    CPatch* patch = m_Patch;
+    CTerrain* terrain = patch->m_Parent;
+
+    max_wdepth = -FLT_MAX;
+    min_wdepth = FLT_MAX;
+    // build vertices, uv, and shader varying
+    for (ssize_t j=0;j<vsize;j++)
+    {
+        for (ssize_t i=0;i<vsize;i++)
+        {
+            ssize_t ix=(patch->m_X*PATCH_SIZE)+i;
+            ssize_t iz=(patch->m_Z*PATCH_SIZE)+j;
+            ssize_t v=(j*vsize)+i;
+
+            // calculate vertex data like for base vertices
+            terrain->CalcPosition(ix,iz,m_WaterVertexData[v].m_Position);
+            // at this step, Y is still terrainHeight
+            const float waterHeight = (cmpWaterManager.null()) ? 0.0f : cmpWaterManager->GetExactWaterLevel(ix,iz);
+            const float wdepth = waterHeight - m_WaterVertexData[v].m_Position.Y;
+            m_WaterVertexData[v].m_Depth = wdepth;
+            // replaces Y by water height
+            m_WaterVertexData[v].m_Position.Y = waterHeight;
+            // calculates U/V (TODO: could be done in for fancy water shader? would be beneficial?)
+            m_WaterVertexData[v].m_UVs[0] = m_WaterVertexData[v].m_Position.X / repeatPeriod;
+            m_WaterVertexData[v].m_UVs[1] = m_WaterVertexData[v].m_Position.Z / repeatPeriod;
+            // update min and max depth over patch
+            if (wdepth > max_wdepth) max_wdepth = wdepth;
+            if (wdepth < min_wdepth) min_wdepth = wdepth;
+        }
+    }
+}
+
+// Build all that can be done at build time for simple water
+void CPatchRData::BuildSimpleWaterVertices()
+{
+    BuildWaterVertexData();
+    // overall depth around patch is ready now
+    // so, if we are fully emerged, we can get rid of things
+    if (FullyEmerged())         // i.e.: (max_wdepth < 0.0f)
+    {
+        if (m_VBWater) {
+            g_VBMan.Release(m_VBWater);
+        }
+    }
+    else
+    {
+        // allocate vertex buffer (only: update is done at render time)
+        if (!m_VBWater) {
+            m_VBWater=g_VBMan.Allocate(sizeof(SSimpleWaterVertex),m_WaterVertexData.size(), GL_STATIC_DRAW, GL_ARRAY_BUFFER);
+        }
+        debug_assert(m_VBWater->m_Index < 65536);
+    }
+
+    // The vertex buffer must be ready for indices calculation
+    BuildWaterIndices();
+}
+
+void CPatchRData::BuildFancyWaterVertices()
+{
+    BuildWaterVertexData();
+    // overall depth around patch is ready now
+    // so, if we are fully emerged, we can get rid of things
+    if (FullyEmerged())         // i.e.: (max_wdepth < 0.0f)
+    {
+        if (m_VBWater) {
+            g_VBMan.Release(m_VBWater);
+        }
+    }
+    else
+    {
+        // we directly use the vertex data for rendering
+        // upload to vertex buffer
+        if (!m_VBWater) {
+            m_VBWater=g_VBMan.Allocate(sizeof(SWaterVertex),m_WaterVertexData.size(), GL_STATIC_DRAW, GL_ARRAY_BUFFER);
+        }
+        m_VBWater->m_Owner->UpdateChunkVertices(m_VBWater,&m_WaterVertexData[0]);
+        debug_assert(m_VBWater->m_Index < 65536);
+    }
+    // The vertex buffer must be ready for indices calculation
+    BuildWaterIndices();
+
+    // We directly use the vertex buffer in rendering, so we
+    // can clear the data buffer for space
+    m_WaterVertexData.clear();
+}
+
+
+void CPatchRData::BuildWaterIndices()
+{
+    // release existing indices
+    m_WaterIndices.clear();
+
+    if (FullyEmerged())
+        return;
+
+    // must have allocated some vertices before trying to build corresponding indices
+    debug_assert(m_VBWater);
+
+    CmpPtr<ICmpWaterManager> cmpWaterManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+
+    CPatch* patch = m_Patch;
+    CTerrain* terrain = patch->m_Parent;
+
+    // build indices for water
+    size_t base_indice=m_VBWater->m_Index;
+
+    for(ssize_t dx=0; dx<PATCH_SIZE; dx++)
+    {
+        for(ssize_t dz=0; dz<PATCH_SIZE; dz++)
+        {
+            ssize_t x = (patch->m_X*PATCH_SIZE + dx);
+            ssize_t z = (patch->m_Z*PATCH_SIZE + dz);
+
+            // Some offsets used to go around counterclockwise while keeping code concise
+            const int DX[] = {1,1,0,0};
+            const int DZ[] = {0,1,1,0};
+
+            const float waterHeight = (cmpWaterManager.null()) ? 0.0f : cmpWaterManager->GetExactWaterLevel(x,z);
+
+            // NB: I do not reuse the values already computed for building the vertex buffer/data
+            // here, even though it would probably be more readable, because it allows to
+            // use the same function for building indices for fancy and non-fancy water (which
+            // have different vertex buffer elements).
+            // But reference visibility info. is for vertices.
+
+            // is any corner of the tile below the water height? if not, no point rendering it
+            bool shouldRender = false;
+            for (int j = 0; j < 4; j++)
+            {
+                const float terrainHeight = terrain->GetVertexGroundLevel(x + DX[j], z + DZ[j]);
+                if (terrainHeight < waterHeight)
+                {
+                    shouldRender = true;
+                    break;
+                }
+            }
+            if (!shouldRender)
+                continue;
+            for (int j=0; j<4; j++)
+            {
+                ssize_t ix = dx + DX[j];
+                ssize_t iz = dz + DZ[j];
+                ssize_t v=(iz*(PATCH_SIZE+1))+ix;
+                m_WaterIndices.push_back(u16(v)+base_indice);
+                debug_assert((u16(v)+base_indice) < 65535);
+            }
+        }
+    }
+}
+
+const float EPSILON = 1e-12;
+
+// if the maximum water size is negative, the patch is entirely emerged
+bool CPatchRData::FullyEmerged()
+{
+    return (max_wdepth < EPSILON);
+}
+// if the minimum water size is still positive, the patch is entirely under water
+bool CPatchRData::EntirelyUnderWater()
+{
+    return (min_wdepth > -EPSILON);
+}
+
+void CPatchRData::RenderSimpleWater()
+{
+    debug_assert(m_UpdateFlags==0);
+
+    if (FullyEmerged())
+        return;
+
+    WaterManager* WaterMgr = g_Renderer.GetWaterManager();
+
+    // This is probably changing so vertices need update!
+    const CCamera& camera = g_Renderer.GetViewCamera();
+    CVector3D camPos = camera.m_Orientation.GetTranslation();
+
+    std::vector<SSimpleWaterVertex> vertices;
+    vertices.reserve(m_WaterVertexData.size());
+
+    // build vertex buffer with adequate alpha 
+    for (unsigned int i=0; i < m_WaterVertexData.size(); i++)
+    {
+        SSimpleWaterVertex vertex;
+        // Copy data identical to build time
+        vertex.m_Position = m_WaterVertexData[i].m_Position;
+        vertex.m_UVs[0] = m_WaterVertexData[i].m_UVs[0];
+        vertex.m_UVs[1] = m_WaterVertexData[i].m_UVs[1];
+        // We use the same pointer/data in array for saving space
+        // vertex.m_PosTex1 = m_WaterVertexData[i].m_Position;
+
+        const float alpha = clamp( (m_WaterVertexData[i].m_Depth) / WaterMgr->m_WaterFullDepth
+                     + WaterMgr->m_WaterAlphaOffset,
+                               WaterMgr->m_WaterAlphaOffset, WaterMgr->m_WaterMaxAlpha);
+
+        // (Crappy) fresnel effect
+        CVector3D CamFaceVertex=CVector3D(vertex.m_Position.X,WaterMgr->m_WaterHeight,vertex.m_Position.Z)-camPos;
+                    // Note: WaterMgr->m_WaterHeight is also vertex.m_Position.Y I think...
+        CamFaceVertex.Normalize();
+        float FresnelScalar = CamFaceVertex.Dot(CVector3D(0.0f, -1.0f, 0.0f));
+        // Invert and set boundaries
+        FresnelScalar = 1.f - (FresnelScalar * 0.6);
+        // Set Color
+        vertex.m_Color.m_X = WaterMgr->m_WaterColor.r;
+        vertex.m_Color.m_Y = WaterMgr->m_WaterColor.g;
+        vertex.m_Color.m_Z = WaterMgr->m_WaterColor.b;
+        vertex.m_Color.m_W = alpha * FresnelScalar;
+
+        // save the finalized vertex built
+        vertices.push_back(vertex);
+    }
+    // upload to vertex buffer
+    m_VBWater->m_Owner->UpdateChunkVertices(m_VBWater,&vertices[0]);
+
+    SSimpleWaterVertex *base=(SSimpleWaterVertex *)m_VBWater->m_Owner->Bind();
+
+    // setup data pointers
+    GLsizei stride = sizeof(SSimpleWaterVertex);
+    glColorPointer(4, GL_FLOAT, stride, &base->m_Color[0]);
+    glVertexPointer(3, GL_FLOAT, stride, &base->m_Position[0]);
+    pglClientActiveTextureARB(GL_TEXTURE0);
+    glTexCoordPointer(2, GL_FLOAT, stride, &base->m_UVs[0]);    // render
+    pglClientActiveTextureARB(GL_TEXTURE1);
+    glTexCoordPointer(3, GL_FLOAT, stride, &base->m_Position[0]);   // (same data as vertex)
+    // glTexCoordPointer(3, GL_FLOAT, stride, &base->m_PosTex1[0]);
+
+    if (!g_Renderer.m_SkipSubmit) {
+        glDrawElements(GL_QUADS, (GLsizei) m_WaterIndices.size(),
+            GL_UNSIGNED_SHORT, &m_WaterIndices[0]);
+    }
+    // bump stats
+    g_Renderer.m_Stats.m_DrawCalls++;
+    // TODO: Water stats?
+
+    CVertexBuffer::Unbind();
+}
+
+void CPatchRData::RenderFancyWater(GLint waterDepth)
+{
+    debug_assert(m_UpdateFlags==0);
+
+    if (FullyEmerged())
+        return;
+
+    SWaterVertex *base=(SWaterVertex *)m_VBWater->m_Owner->Bind();
+
+    // setup data pointers
+    GLsizei stride = sizeof(SWaterVertex);
+    glVertexPointer(3, GL_FLOAT, stride, &base->m_Position[0]);
+    pglClientActiveTextureARB(GL_TEXTURE0);
+    glTexCoordPointer(2, GL_FLOAT, stride, &base->m_UVs[0]);
+    pglVertexAttribPointerARB(waterDepth, 1, GL_FLOAT, GL_FALSE, /* not to be normalized */
+            stride, &base->m_Depth);
+    // render
+    if (!g_Renderer.m_SkipSubmit) {
+        glDrawElements(GL_QUADS, (GLsizei) m_WaterIndices.size(),
+            GL_UNSIGNED_SHORT, &m_WaterIndices[0]);
+    }
+    // bump stats
+    g_Renderer.m_Stats.m_DrawCalls++;
+    // TODO: Water stats?
+
+    CVertexBuffer::Unbind();
+
+}
+

source/renderer/TerrainRenderer.cpp

@@ -161 +161 @@
     m->phase = Phase_Submit;
 }
 
-
 ///////////////////////////////////////////////////////////////////
 // Full-featured terrain rendering with blending and everything
 void TerrainRenderer::RenderTerrain(ShadowMap* shadow)
@@ -521 +520 @@
     glDisableClientState(GL_VERTEX_ARRAY);
 }
 
-
-///////////////////////////////////////////////////////////////////
-// Render water that is part of the terrain
-void TerrainRenderer::RenderWater()
+// Render fancy water
+bool TerrainRenderer::RenderFancyWater()
 {
-    PROFILE( "render water" );
+    PROFILE( "render fancy water" );
 
     WaterManager* WaterMgr = g_Renderer.GetWaterManager();
 
-    bool fancy = WaterMgr->WillRenderFancyWater();
-
-    // If we're using fancy water, make sure its shader is loaded
-    if(fancy && !m->fancyWaterShader)
+    // We're using fancy water, make sure its shader is loaded
+    if(!m->fancyWaterShader)
     {
         Handle h = ogl_program_load(g_VFS, L"shaders/water_high.xml");
         if (h < 0)
         {
             LOGERROR(L"Failed to load water shader. Falling back to non-fancy water.\n");
             g_Renderer.m_Options.m_FancyWater = false;
-            fancy = false;
+            return false;
         }
         else
         {
             m->fancyWaterShader = h;
         }
     }
-    CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
     CLOSTexture& losTexture = g_Game->GetView()->GetLOSTexture();
     
@@ -561 +555 @@
     double period = 1.6;
     int curTex = (int)(time*60/period) % 60;
 
-    if(fancy)
-    {
-        WaterMgr->m_NormalMap[curTex]->Bind();
-    }
-    else
-    {
-        WaterMgr->m_WaterTexture[curTex]->Bind();
-    }
+    WaterMgr->m_NormalMap[curTex]->Bind();
 
     // Shift the texture coordinates by these amounts to make the water "flow"
     float tx = -fmod(time, 81.0)/81.0;
     float ty = -fmod(time, 34.0)/34.0;
 
-    if(!fancy)
-    {
-        // Perform the shifting by modifying the texture matrix
-        glMatrixMode(GL_TEXTURE);
-        glLoadIdentity();
-        glTranslatef(tx, ty, 0);
-
-        // Set up texture environment to multiply vertex RGB by texture RGB and use vertex alpha
-        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
-        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
-        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
-        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
-        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR_ARB);
-        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
-        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
-        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PRIMARY_COLOR_ARB);
-        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
-
-        // Multiply by LOS texture
-        losTexture.BindTexture(1);
-        pglClientActiveTextureARB(GL_TEXTURE1);
-        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-
-        glLoadMatrixf(losTexture.GetTextureMatrix());
-
-        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
-        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
-        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
-        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
-        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
-        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_ALPHA);
-        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
-        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS);
-        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
-    }
-
     // Set the proper LOD bias
     glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, g_Renderer.m_Options.m_LodBias);
 
     const CCamera& camera = g_Renderer.GetViewCamera();
     CVector3D camPos = camera.m_Orientation.GetTranslation();
 
-    GLint vertexDepth = 0;  // water depth attribute, if using fancy water
+    // Bind reflection and refraction textures on texture units 1 and 2
+    pglActiveTextureARB( GL_TEXTURE1_ARB );
+    glEnable( GL_TEXTURE_2D );
+    glBindTexture( GL_TEXTURE_2D, WaterMgr->m_ReflectionTexture );
+    pglActiveTextureARB( GL_TEXTURE2_ARB );
+    glEnable( GL_TEXTURE_2D );
+    glBindTexture( GL_TEXTURE_2D, WaterMgr->m_RefractionTexture );
 
-    if(fancy)
-    {
-        // Bind reflection and refraction textures on texture units 1 and 2
-        pglActiveTextureARB( GL_TEXTURE1_ARB );
-        glEnable( GL_TEXTURE_2D );
-        glBindTexture( GL_TEXTURE_2D, WaterMgr->m_ReflectionTexture );
-        pglActiveTextureARB( GL_TEXTURE2_ARB );
-        glEnable( GL_TEXTURE_2D );
-        glBindTexture( GL_TEXTURE_2D, WaterMgr->m_RefractionTexture );
+    losTexture.BindTexture(3);
 
-        losTexture.BindTexture(3);
+    // Bind water shader and set arguments
+    ogl_program_use( m->fancyWaterShader );
 
-        // Bind water shader and set arguments
-        ogl_program_use( m->fancyWaterShader );
+    GLint ambient = ogl_program_get_uniform_location( m->fancyWaterShader, "ambient" );
+    GLint sunDir = ogl_program_get_uniform_location( m->fancyWaterShader, "sunDir" );
+    GLint sunColor = ogl_program_get_uniform_location( m->fancyWaterShader, "sunColor" );
+    GLint cameraPos = ogl_program_get_uniform_location( m->fancyWaterShader, "cameraPos" );
+    GLint shininess = ogl_program_get_uniform_location( m->fancyWaterShader, "shininess" );
+    GLint specularStrength = ogl_program_get_uniform_location( m->fancyWaterShader, "specularStrength" );
+    GLint waviness = ogl_program_get_uniform_location( m->fancyWaterShader, "waviness" );
+    GLint murkiness = ogl_program_get_uniform_location( m->fancyWaterShader, "murkiness" );
+    GLint fullDepth = ogl_program_get_uniform_location( m->fancyWaterShader, "fullDepth" );
+    GLint tint = ogl_program_get_uniform_location( m->fancyWaterShader, "tint" );
+    GLint reflectionTint = ogl_program_get_uniform_location( m->fancyWaterShader, "reflectionTint" );
+    GLint reflectionTintStrength = ogl_program_get_uniform_location( m->fancyWaterShader, "reflectionTintStrength" );
+    GLint translation = ogl_program_get_uniform_location( m->fancyWaterShader, "translation" );
+    GLint reflectionMatrix = ogl_program_get_uniform_location( m->fancyWaterShader, "reflectionMatrix" );
+    GLint refractionMatrix = ogl_program_get_uniform_location( m->fancyWaterShader, "refractionMatrix" );
+    GLint losMatrix = ogl_program_get_uniform_location( m->fancyWaterShader, "losMatrix" );
+    GLint normalMap = ogl_program_get_uniform_location( m->fancyWaterShader, "normalMap" );
+    GLint reflectionMap = ogl_program_get_uniform_location( m->fancyWaterShader, "reflectionMap" );
+    GLint refractionMap = ogl_program_get_uniform_location( m->fancyWaterShader, "refractionMap" );
+    GLint losMap = ogl_program_get_uniform_location( m->fancyWaterShader, "losMap" );
 
-        GLint ambient = ogl_program_get_uniform_location( m->fancyWaterShader, "ambient" );
-        GLint sunDir = ogl_program_get_uniform_location( m->fancyWaterShader, "sunDir" );
-        GLint sunColor = ogl_program_get_uniform_location( m->fancyWaterShader, "sunColor" );
-        GLint cameraPos = ogl_program_get_uniform_location( m->fancyWaterShader, "cameraPos" );
-        GLint shininess = ogl_program_get_uniform_location( m->fancyWaterShader, "shininess" );
-        GLint specularStrength = ogl_program_get_uniform_location( m->fancyWaterShader, "specularStrength" );
-        GLint waviness = ogl_program_get_uniform_location( m->fancyWaterShader, "waviness" );
-        GLint murkiness = ogl_program_get_uniform_location( m->fancyWaterShader, "murkiness" );
-        GLint fullDepth = ogl_program_get_uniform_location( m->fancyWaterShader, "fullDepth" );
-        GLint tint = ogl_program_get_uniform_location( m->fancyWaterShader, "tint" );
-        GLint reflectionTint = ogl_program_get_uniform_location( m->fancyWaterShader, "reflectionTint" );
-        GLint reflectionTintStrength = ogl_program_get_uniform_location( m->fancyWaterShader, "reflectionTintStrength" );
-        GLint translation = ogl_program_get_uniform_location( m->fancyWaterShader, "translation" );
-        GLint reflectionMatrix = ogl_program_get_uniform_location( m->fancyWaterShader, "reflectionMatrix" );
-        GLint refractionMatrix = ogl_program_get_uniform_location( m->fancyWaterShader, "refractionMatrix" );
-        GLint losMatrix = ogl_program_get_uniform_location( m->fancyWaterShader, "losMatrix" );
-        GLint normalMap = ogl_program_get_uniform_location( m->fancyWaterShader, "normalMap" );
-        GLint reflectionMap = ogl_program_get_uniform_location( m->fancyWaterShader, "reflectionMap" );
-        GLint refractionMap = ogl_program_get_uniform_location( m->fancyWaterShader, "refractionMap" );
-        GLint losMap = ogl_program_get_uniform_location( m->fancyWaterShader, "losMap" );
+    const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
+    pglUniform3fvARB( ambient, 1, &lightEnv.m_TerrainAmbientColor.X );
+    pglUniform3fvARB( sunDir, 1, &lightEnv.GetSunDir().X );
+    pglUniform3fvARB( sunColor, 1, &lightEnv.m_SunColor.X );
+    pglUniform1fARB( shininess, WaterMgr->m_Shininess );
+    pglUniform1fARB( specularStrength, WaterMgr->m_SpecularStrength );
+    pglUniform1fARB( waviness, WaterMgr->m_Waviness );
+    pglUniform1fARB( murkiness, WaterMgr->m_Murkiness );
+    pglUniform1fARB( fullDepth, WaterMgr->m_WaterFullDepth );
+    pglUniform3fvARB( tint, 1, WaterMgr->m_WaterTint.FloatArray() );
+    pglUniform1fARB( reflectionTintStrength, WaterMgr->m_ReflectionTintStrength );
+    pglUniform3fvARB( reflectionTint, 1, WaterMgr->m_ReflectionTint.FloatArray() );
+    pglUniform4fARB( translation, tx, ty, 0, 0 );
+    pglUniformMatrix4fvARB( reflectionMatrix, 1, false, &WaterMgr->m_ReflectionMatrix._11 );
+    pglUniformMatrix4fvARB( refractionMatrix, 1, false, &WaterMgr->m_RefractionMatrix._11 );
+    pglUniformMatrix4fvARB( losMatrix, 1, false, losTexture.GetTextureMatrix() );
+    pglUniform1iARB( normalMap, 0 );        // texture unit 0
+    pglUniform1iARB( reflectionMap, 1 );    // texture unit 1
+    pglUniform1iARB( refractionMap, 2 );    // texture unit 2
+    pglUniform1iARB( losMap, 3 );           // texture unit 3
+    pglUniform3fvARB( cameraPos, 1, &camPos.X );
 
-        const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
-        pglUniform3fvARB( ambient, 1, &lightEnv.m_TerrainAmbientColor.X );
-        pglUniform3fvARB( sunDir, 1, &lightEnv.GetSunDir().X );
-        pglUniform3fvARB( sunColor, 1, &lightEnv.m_SunColor.X );
-        pglUniform1fARB( shininess, WaterMgr->m_Shininess );
-        pglUniform1fARB( specularStrength, WaterMgr->m_SpecularStrength );
-        pglUniform1fARB( waviness, WaterMgr->m_Waviness );
-        pglUniform1fARB( murkiness, WaterMgr->m_Murkiness );
-        pglUniform1fARB( fullDepth, WaterMgr->m_WaterFullDepth );
-        pglUniform3fvARB( tint, 1, WaterMgr->m_WaterTint.FloatArray() );
-        pglUniform1fARB( reflectionTintStrength, WaterMgr->m_ReflectionTintStrength );
-        pglUniform3fvARB( reflectionTint, 1, WaterMgr->m_ReflectionTint.FloatArray() );
-        pglUniform4fARB( translation, tx, ty, 0, 0 );
-        pglUniformMatrix4fvARB( reflectionMatrix, 1, false, &WaterMgr->m_ReflectionMatrix._11 );
-        pglUniformMatrix4fvARB( refractionMatrix, 1, false, &WaterMgr->m_RefractionMatrix._11 );
-        pglUniformMatrix4fvARB( losMatrix, 1, false, losTexture.GetTextureMatrix() );
-        pglUniform1iARB( normalMap, 0 );        // texture unit 0
-        pglUniform1iARB( reflectionMap, 1 );    // texture unit 1
-        pglUniform1iARB( refractionMap, 2 );    // texture unit 2
-        pglUniform1iARB( losMap, 3 );           // texture unit 3
-        pglUniform3fvARB( cameraPos, 1, &camPos.X );
+//  glActiveTexture(GL_TEXTURE0);
 
-        vertexDepth = ogl_program_get_attrib_location( m->fancyWaterShader, "vertexDepth" );
-    }
-    
-    float repeatPeriod = (fancy ? WaterMgr->m_RepeatPeriod : 16.0f);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    pglClientActiveTextureARB(GL_TEXTURE0_ARB);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
-    glBegin(GL_QUADS);
-
+    // water depth attribute, when using fancy water
+    GLint vertexDepth = ogl_program_get_attrib_location( m->fancyWaterShader, "vertexDepth" );
+    pglEnableVertexAttribArrayARB(vertexDepth);
+    
     for(size_t i=0; i<m->visiblePatches.size(); i++)
     {
-        CPatch* patch = m->visiblePatches[i]->GetPatch();
+        CPatchRData* patchdata = m->visiblePatches[i];
+        patchdata->RenderFancyWater(vertexDepth);
+    }
 
-        for(ssize_t dx=0; dx<PATCH_SIZE; dx++)
-        {
-            for(ssize_t dz=0; dz<PATCH_SIZE; dz++)
-            {
-                ssize_t x = (patch->m_X*PATCH_SIZE + dx);
-                ssize_t z = (patch->m_Z*PATCH_SIZE + dz);
+    pglDisableVertexAttribArrayARB(vertexDepth);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_VERTEX_ARRAY);
 
-                // Some offsets used to go around counterclockwise while keeping code concise
-                const int DX[] = {1,1,0,0};
-                const int DZ[] = {0,1,1,0};
+    // Unbind the LOS/refraction/reflection textures and the shader
+    g_Renderer.BindTexture(3, 0);
+    g_Renderer.BindTexture(2, 0);
+    g_Renderer.BindTexture(1, 0);
+    pglActiveTextureARB(GL_TEXTURE0_ARB);
+    ogl_program_use(0);
 
-                // is any corner of the tile below the water height? if not, no point rendering it
-                bool shouldRender = false;
-                for (int j = 0; j < 4; j++)
-                {
-                    float terrainHeight = terrain->GetVertexGroundLevel(x + DX[j], z + DZ[j]);
-                    if (terrainHeight < WaterMgr->m_WaterHeight)
-                    {
-                        shouldRender = true;
-                        break;
-                    }
-                }
-                if (!shouldRender)
-                    continue;
+    glMatrixMode(GL_MODELVIEW);
+    glDisable(GL_BLEND);
+    glDisable(GL_TEXTURE_2D);
 
-                for (int j=0; j<4; j++)
-                {
-                    ssize_t ix = x + DX[j];
-                    ssize_t iz = z + DZ[j];
+    return true;
+}
 
-                    float vertX = ix * CELL_SIZE;
-                    float vertZ = iz * CELL_SIZE;
+void TerrainRenderer::RenderSimpleWater()
+{
+    PROFILE( "render simple water" );
 
-                    float terrainHeight = terrain->GetVertexGroundLevel(ix, iz);
+    WaterManager* WaterMgr = g_Renderer.GetWaterManager();
 
-                    if (fancy)
-                    {
-                        pglVertexAttrib1fARB(vertexDepth, WaterMgr->m_WaterHeight - terrainHeight);
-                        pglMultiTexCoord2fARB(GL_TEXTURE0, vertX/repeatPeriod, vertZ/repeatPeriod);
-                        glVertex3f(vertX, WaterMgr->m_WaterHeight, vertZ);
-                    }
-                    else
-                    {
-                        float alpha = clamp( (WaterMgr->m_WaterHeight - terrainHeight) / WaterMgr->m_WaterFullDepth + WaterMgr->m_WaterAlphaOffset,
-                                              WaterMgr->m_WaterAlphaOffset, WaterMgr->m_WaterMaxAlpha);
+    CLOSTexture& losTexture = g_Game->GetView()->GetLOSTexture();
+    
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+    glEnable(GL_DEPTH_TEST);
+    glDepthFunc(GL_LEQUAL);
 
-                        // (Crappy) fresnel effect
-                        CVector3D CamFaceVertex=CVector3D(vertX,WaterMgr->m_WaterHeight,vertZ)-camPos;
-                        CamFaceVertex.Normalize();
-                        float FresnelScalar = CamFaceVertex.Dot(CVector3D(0.0f, -1.0f, 0.0f));
-                        // Invert and set boundaries
-                        FresnelScalar = 1.f - (FresnelScalar * 0.6);
+    double time = WaterMgr->m_WaterTexTimer;
 
-                        glColor4f(WaterMgr->m_WaterColor.r,
-                                  WaterMgr->m_WaterColor.g,
-                                  WaterMgr->m_WaterColor.b,
-                                  alpha * FresnelScalar);
-                        pglMultiTexCoord2fARB(GL_TEXTURE0, vertX/repeatPeriod, vertZ/repeatPeriod);
-                        pglMultiTexCoord3fARB(GL_TEXTURE1, vertX, WaterMgr->m_WaterHeight, vertZ);
-                        glVertex3f(vertX, WaterMgr->m_WaterHeight, vertZ);
-                    }
+    double period = 16.0f;
+    int curTex = (int)(time*60/period) % 60;
 
-                }
-            }   //end of x loop
-        }   //end of z loop
-    }
-    glEnd();
+    WaterMgr->m_WaterTexture[curTex]->Bind();
 
-    if (fancy)
-    {
-        // Unbind the LOS/refraction/reflection textures and the shader
+    // Shift the texture coordinates by these amounts to make the water "flow"
+    float tx = -fmod(time, 81.0)/81.0;
+    float ty = -fmod(time, 34.0)/34.0;
 
-        g_Renderer.BindTexture(3, 0);
-        g_Renderer.BindTexture(2, 0);
-        g_Renderer.BindTexture(1, 0);
+    // Perform the shifting by modifying the texture matrix
+    glMatrixMode(GL_TEXTURE);
+    glLoadIdentity();
+    glTranslatef(tx, ty, 0);
 
-        pglActiveTextureARB(GL_TEXTURE0_ARB);
+    // Set up texture environment to multiply vertex RGB by texture RGB and use vertex alpha
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PRIMARY_COLOR_ARB);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
 
-        ogl_program_use(0);
-    }
+    // Multiply by LOS texture
+    losTexture.BindTexture(1);
+    pglClientActiveTextureARB(GL_TEXTURE1);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
-    if (!fancy)
-    {
-        g_Renderer.BindTexture(1, 0);
-        pglClientActiveTextureARB(GL_TEXTURE1_ARB);
-        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glLoadMatrixf(losTexture.GetTextureMatrix());
 
-        glLoadIdentity();
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_ALPHA);
+    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
+    glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
 
-        pglActiveTextureARB(GL_TEXTURE0_ARB);
-        pglClientActiveTextureARB(GL_TEXTURE0_ARB);
 
-        // Clean up the texture matrix and blend mode
-        glLoadIdentity();
-        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    // Set the proper LOD bias
+    glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, g_Renderer.m_Options.m_LodBias);
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    pglClientActiveTextureARB(GL_TEXTURE0_ARB);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    for(size_t i=0; i<m->visiblePatches.size(); i++)
+    {
+        CPatchRData* patchdata = m->visiblePatches[i];
+        patchdata->RenderSimpleWater();
     }
 
+    pglClientActiveTextureARB(GL_TEXTURE0_ARB);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_COLOR_ARRAY);
+    glDisableClientState(GL_VERTEX_ARRAY);
+
+    g_Renderer.BindTexture(1, 0);
+    pglClientActiveTextureARB(GL_TEXTURE1_ARB);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glLoadIdentity();
+
+    pglActiveTextureARB(GL_TEXTURE0_ARB);
+    pglClientActiveTextureARB(GL_TEXTURE0_ARB);
+
+    // Clean up the texture matrix and blend mode
+    glLoadIdentity();
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+
     glMatrixMode(GL_MODELVIEW);
     glDisable(GL_BLEND);
     glDisable(GL_TEXTURE_2D);
 }
 
+
+///////////////////////////////////////////////////////////////////
+// Render water that is part of the terrain
+void TerrainRenderer::RenderWater()
+{
+    // PROFILE is defined in one of the sub functions
+
+    WaterManager* WaterMgr = g_Renderer.GetWaterManager();
+
+    bool fancy = WaterMgr->WillRenderFancyWater();
+
+    if (fancy) {
+        bool r = RenderFancyWater();
+        if (r) return;
+    }
+    RenderSimpleWater();
+}
+
 void TerrainRenderer::RenderPriorities()
 {
     PROFILE("render priorities");

binaries/data/mods/public/shaders/water_high.vs

@@ -15 +15 @@
     waterDepth = vertexDepth;
     gl_TexCoord[0] = gl_MultiTexCoord0 + translation;
     gl_TexCoord[1] = reflectionMatrix * gl_Vertex;      // projective texturing
-    gl_TexCoord[2] = reflectionMatrix * gl_Vertex;
+    gl_TexCoord[2] = refractionMatrix * gl_Vertex;
     gl_TexCoord[3] = losMatrix * gl_Vertex;
     w = gl_TexCoord[1].w;
     gl_Position = ftransform();