Ticket #794: Camera.patch

binaries/data/config/default.cfg

@@ -95 +95 @@
 view.near = 2.0                             ; Near plane distance
 view.far = 4096.0                           ; Far plane distance
 view.fov = 45.0                             ; Field of view (degrees), lower is narrow, higher is wide
+view.height.smoothness = 0.5
+view.height.min = 16
 
 ; HOTKEY MAPPINGS:
 

source/graphics/GameView.cpp

@@ -190 +190 @@
         JoystickRotateY(-1),
         JoystickZoomIn(-1),
         JoystickZoomOut(-1),
+        HeightSmoothness(0.5f),
+        HeightMin(16.f),
 
         PosX(0, 0, 0.01f),
         PosY(0, 0, 0.01f),
@@ -289 +291 @@
     int JoystickRotateY;
     int JoystickZoomIn;
     int JoystickZoomOut;
+    float HeightSmoothness;
+    float HeightMin;
 
     ////////////////////////////////////////
     // Camera Controls State
@@ -426 +430 @@
     CFG_GET_SYS_VAL("joystick.camera.zoom.in", Int, m->JoystickZoomIn);
     CFG_GET_SYS_VAL("joystick.camera.zoom.out", Int, m->JoystickZoomOut);
 
+    CFG_GET_SYS_VAL("view.height.smoothness", Float, m->HeightSmoothness);
+    CFG_GET_SYS_VAL("view.height.min", Float, m->HeightMin);
+
     CFG_GET_SYS_VAL("view.pos.smoothness", Float, m->PosX.m_Smoothness);
     CFG_GET_SYS_VAL("view.pos.smoothness", Float, m->PosY.m_Smoothness);
     CFG_GET_SYS_VAL("view.pos.smoothness", Float, m->PosZ.m_Smoothness);
@@ -595 +602 @@
     g_Renderer.GetWaterManager()->UnloadWaterTextures();
 }
 
+static void FocusHeight(CGameViewImpl* m, bool smooth)
+{
+    /*
+        The camera pivot height is moved towards ground level.
+        To prevent excessive zoom when looking over a cliff, 
+        the target ground level is the maximum of the ground level at the camera's near and pivot points.
+        The ground levels are filtered to achieve smooth camera movement.
+        The filter radius is proportional to the zoom level.
+        The camera height is clamped to prevent map penetration.
+    */
 
-static void ClampDistance(CGameViewImpl* m, bool smooth)
-{
     if (!m->ConstrainCamera)
         return;
 
     CCamera targetCam = m->ViewCamera;
     SetupCameraMatrixSmoothRot(m, &targetCam.m_Orientation);
 
-    CVector3D forwards = targetCam.m_Orientation.GetIn();
+    const CVector3D position = targetCam.m_Orientation.GetTranslation();
+    const CVector3D forwards = targetCam.m_Orientation.GetIn();
 
-    CVector3D delta = targetCam.GetFocus() - targetCam.m_Orientation.GetTranslation();
+    // horizontal view radius
+    const float radius = hypot( forwards.X, forwards.Z ) * m->Zoom.GetSmoothedValue();
+    const float near_radius = radius * m->HeightSmoothness;
+    const float pivot_radius = radius * m->HeightSmoothness;
 
-    float dist = delta.Dot(forwards);
-    float clampedDist = Clamp(dist, m->ViewZoomMin, m->ViewZoomMax);
-    float diff = clampedDist - dist;
+    const CVector3D nearPoint = position + forwards * m->ViewNear;
+    const CVector3D pivotPoint = position + forwards * m->Zoom.GetSmoothedValue();
 
+    const float ground = m->Game->GetWorld()->GetTerrain()->GetExactGroundLevel(nearPoint.X, nearPoint.Z);
+
+    // filter ground levels for smooth camera movement
+    const float filtered_near_ground = m->Game->GetWorld()->GetTerrain()->GetFilteredGroundLevel(nearPoint.X, nearPoint.Z, near_radius);
+    const float filtered_pivot_ground = m->Game->GetWorld()->GetTerrain()->GetFilteredGroundLevel(pivotPoint.X, pivotPoint.Z, pivot_radius);
+    
+    // filtered maximum visible ground level in view
+    const float filtered_ground = std::max<float>(filtered_near_ground, filtered_pivot_ground);
+
+    // target camera height above pivot point
+    const float pivot_height = -forwards.Y * (m->Zoom.GetSmoothedValue() - m->ViewNear);
+    // minimum camera height above filtered ground level
+    const float min_height = (m->HeightMin + ground - filtered_ground);
+
+    const float target_height = std::max<float>(pivot_height , min_height);
+    const float height = (nearPoint.Y - filtered_ground);
+    const float diff = target_height - height;
+
     if (!diff)
         return;
 
     if (smooth)
     {
-        m->PosX.AddSmoothly(forwards.X * -diff);
-        m->PosY.AddSmoothly(forwards.Y * -diff);
-        m->PosZ.AddSmoothly(forwards.Z * -diff);
+        m->PosY.AddSmoothly(diff);
     }
     else
     {
-        m->PosX.Add(forwards.X * -diff);
-        m->PosY.Add(forwards.Y * -diff);
-        m->PosZ.Add(forwards.Z * -diff);
+        m->PosY.Add(diff);
     }
 }
 
+CVector3D CGameView::GetSmoothPivot(CCamera &camera) const
+{
+    ENSURE( m != 0 );
+    return camera.m_Orientation.GetTranslation() + camera.m_Orientation.GetIn() * m->Zoom.GetSmoothedValue();
+}
+
 void CGameView::Update(float DeltaTime)
 {
     // If camera movement is being handled by the touch-input system,
@@ -758 +796 @@
                 // Move the camera to match the unit
                 CCamera targetCam = m->ViewCamera;
                 SetupCameraMatrixSmoothRot(m, &targetCam.m_Orientation);
-
-                CVector3D pivot = targetCam.GetFocus();
+                
+                CVector3D pivot = GetSmoothPivot(targetCam);
                 CVector3D delta = pos - pivot;
                 m->PosX.AddSmoothly(delta.X);
                 m->PosY.AddSmoothly(delta.Y);
@@ -774 +812 @@
     }
 
     if (HotkeyIsPressed("camera.zoom.in"))
+        m->Zoom.AddSmoothly(-m->ViewZoomSpeed * DeltaTime);
+    if (HotkeyIsPressed("camera.zoom.out"))
         m->Zoom.AddSmoothly(m->ViewZoomSpeed * DeltaTime);
-    if (HotkeyIsPressed("camera.zoom.out"))
-        m->Zoom.AddSmoothly(-m->ViewZoomSpeed * DeltaTime);
 
-    float zoomDelta = m->Zoom.Update(DeltaTime);
+    if (m->ConstrainCamera)
+        m->Zoom.ClampSmoothly( m->ViewZoomMin, m->ViewZoomMax );
+
+    float zoomDelta = -m->Zoom.Update(DeltaTime);
     if (zoomDelta)
     {
         CVector3D forwards = m->ViewCamera.m_Orientation.GetIn();
@@ -790 +831 @@
     if (m->ConstrainCamera)
         m->RotateX.ClampSmoothly(DEGTORAD(m->ViewRotateXMin), DEGTORAD(m->ViewRotateXMax));
 
-    ClampDistance(m, true);
+    FocusHeight(m, true);
 
     // Ensure the ViewCamera focus is inside the map with the chosen margins
     // if not so - apply margins to the camera
@@ -801 +842 @@
 
         CTerrain* pTerrain = m->Game->GetWorld()->GetTerrain();
 
-        CVector3D pivot = targetCam.GetFocus();
+        CVector3D pivot = GetSmoothPivot(targetCam);
         CVector3D delta = targetCam.m_Orientation.GetTranslation() - pivot;
 
         CVector3D desiredPivot = pivot;
@@ -846 +887 @@
 
             CVector3D upwards(0.0f, 1.0f, 0.0f);
 
-            CVector3D pivot = targetCam.GetFocus();
+            CVector3D pivot = GetSmoothPivot(targetCam);
             CVector3D delta = targetCam.m_Orientation.GetTranslation() - pivot;
 
             CQuaternion q;
@@ -869 +910 @@
         {
             CVector3D rightwards = targetCam.m_Orientation.GetLeft() * -1.0f;
 
-            CVector3D pivot = m->ViewCamera.GetFocus();
+            CVector3D pivot = GetSmoothPivot(targetCam);
             CVector3D delta = targetCam.m_Orientation.GetTranslation() - pivot;
 
             CQuaternion q;
@@ -919 +960 @@
     CCamera targetCam = m->ViewCamera;
     SetupCameraMatrixNonSmooth(m, &targetCam.m_Orientation);
 
-    CVector3D pivot = targetCam.GetFocus();
+    CVector3D pivot = GetSmoothPivot(targetCam);
     CVector3D delta = target - pivot;
     
     m->PosX.SetValueSmoothly(delta.X + m->PosX.GetValue());
     m->PosZ.SetValueSmoothly(delta.Z + m->PosZ.GetValue());
 
-    ClampDistance(m, false);
+    FocusHeight(m, false);
 
     // Break out of following mode so the camera really moves to the target
     m->FollowEntity = INVALID_ENTITY;
@@ -944 +985 @@
     m->PosZ.SetValue(target.Z - delta.Z);
     m->RotateX.SetValue(DEGTORAD(m->ViewRotateXDefault));
     m->RotateY.SetValue(DEGTORAD(m->ViewRotateYDefault));
+    m->Zoom.SetValue(m->ViewZoomDefault);
 
-    ClampDistance(m, false);
+    FocusHeight(m, false);
 
     SetupCameraMatrixSmooth(m, &m->ViewCamera.m_Orientation);
     m->ViewCamera.UpdateFrustum();
@@ -961 +1003 @@
 
     // Compute the zoom adjustment to get us back to the default
     CVector3D forwards = targetCam.m_Orientation.GetIn();
-    CVector3D delta = targetCam.GetFocus() - targetCam.m_Orientation.GetTranslation();
+
+    CVector3D pivot = GetSmoothPivot(targetCam);
+    CVector3D delta = pivot - targetCam.m_Orientation.GetTranslation();
     float dist = delta.Dot(forwards);
     m->Zoom.AddSmoothly(dist - m->ViewZoomDefault);
 
@@ -1049 +1093 @@
         // and we never get to see the "down" state inside Update().
         else if (hotkey == "camera.zoom.wheel.in")
         {
-            m->Zoom.AddSmoothly(m->ViewZoomSpeedWheel);
+            m->Zoom.AddSmoothly(-m->ViewZoomSpeedWheel);
             return IN_HANDLED;
         }
         else if (hotkey == "camera.zoom.wheel.out")
         {
-            m->Zoom.AddSmoothly(-m->ViewZoomSpeedWheel);
+            m->Zoom.AddSmoothly(m->ViewZoomSpeedWheel);
             return IN_HANDLED;
         }
         else if (hotkey == "camera.rotate.wheel.cw")

source/graphics/GameView.h

@@ -85 +85 @@
     void CameraFollow(entity_id_t entity, bool firstPerson);
     entity_id_t GetFollowedEntity();
 
+    CVector3D GetSmoothPivot(CCamera &camera) const;
+
     float GetNear() const;
     float GetFar() const;
     float GetFOV() const;

source/graphics/HeightMipmap.cpp

@@ +1 @@
+/* Copyright (C) 2012 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "HeightMipmap.h"
+#include "lib/bits.h"
+
+CHeightMipmap::CHeightMipmap()
+{};
+
+CHeightMipmap::~CHeightMipmap()
+{
+    ReleaseData();
+}
+
+void CHeightMipmap::ReleaseData()
+{
+    for (size_t i = 0 ; i < m_Mipmap.size(); ++i) 
+    {
+        delete [] m_Mipmap[i].m_Heightmap;
+        m_Mipmap[i].m_MapSize = 0;
+    }
+    m_Mipmap.clear();
+}
+
+void CHeightMipmap::Update(const u16* ptr)
+{
+    ENSURE( ptr != 0 );
+
+    Update(ptr, 0, 0, m_MapSize, m_MapSize);
+}
+
+void CHeightMipmap::Update(const u16* ptr, size_t left, size_t bottom, size_t right, size_t top)
+{
+    ENSURE( ptr != 0 );
+
+    size_t mapSize = m_MapSize;
+    
+    for (size_t i = 0; i < m_Mipmap.size(); ++i) 
+    {
+        // update window
+        left = clamp<size_t>( (size_t)floorf((left / mapSize) * m_Mipmap[i].m_MapSize), 0, m_Mipmap[i].m_MapSize - 1 );
+        bottom = clamp<size_t>( (size_t)floorf((bottom / mapSize) * m_Mipmap[i].m_MapSize), 0, m_Mipmap[i].m_MapSize - 1 );
+
+        right = clamp<size_t>( (size_t)ceilf((right / mapSize) * m_Mipmap[i].m_MapSize), 0, m_Mipmap[i].m_MapSize );
+        top = clamp<size_t>( (size_t)ceilf((top / mapSize) * m_Mipmap[i].m_MapSize), 0, m_Mipmap[i].m_MapSize );
+
+        // update mipmap
+        BilinearUpdate(m_Mipmap[i], mapSize, ptr, left, bottom, right, top);
+
+        mapSize = m_Mipmap[i].m_MapSize;
+        ptr = m_Mipmap[i].m_Heightmap;
+    }
+}
+
+void CHeightMipmap::Initialize(size_t mapSize, const u16* ptr)
+{
+    ENSURE( ptr != 0 );
+    ENSURE( mapSize > 0 );
+
+    ReleaseData();
+
+    m_MapSize = mapSize;
+    size_t mipmapSize = round_down_to_pow2(mapSize);
+
+    while (mipmapSize > 1) 
+    {
+        m_Mipmap.push_back(SMipmap(mipmapSize, new u16[mipmapSize*mipmapSize]));
+        mipmapSize >>= 1;
+    };
+
+    Update(ptr);
+}
+
+float CHeightMipmap::GetTrilinearGroundLevel(float x, float z, float radius) const
+{
+    const float y = clamp<float>(logf(radius * m_Mipmap[0].m_MapSize) / logf(2), 0, m_Mipmap.size());
+    const size_t iy = (size_t)clamp<ssize_t>((ssize_t)floorf(y), 0, m_Mipmap.size() - 1);
+
+    const float fy = y - iy;
+
+    const float h0 = BilinearFilter(m_Mipmap[iy], x, z);
+    const float h1 = BilinearFilter(m_Mipmap[iy + 1], x, z);
+
+    return (1 - fy) * h0 + fy * h1;
+}
+
+float CHeightMipmap::BilinearFilter(const SMipmap &mipmap, float x, float z) const
+{
+    x *= mipmap.m_MapSize;
+    z *= mipmap.m_MapSize;
+
+    const size_t xi = (size_t)clamp<ssize_t>((ssize_t)floor(x), 0, mipmap.m_MapSize - 1);
+    const size_t zi = (size_t)clamp<ssize_t>((ssize_t)floor(z), 0, mipmap.m_MapSize - 1);
+
+    const float xf = clamp<float>(x-xi, 0.0f, 1.0f);
+    const float zf = clamp<float>(z-zi, 0.0f, 1.0f);
+
+    const float h00 = mipmap.m_Heightmap[zi*mipmap.m_MapSize + xi];
+    const float h01 = mipmap.m_Heightmap[(zi+1)*mipmap.m_MapSize + xi];
+    const float h10 = mipmap.m_Heightmap[zi*mipmap.m_MapSize + (xi+1)];
+    const float h11 = mipmap.m_Heightmap[(zi+1)*mipmap.m_MapSize + (xi+1)];
+
+    return
+        (1.f - xf) * (1.f - zf) * h00 +
+               xf  * (1.f - zf) * h10 +
+        (1.f - xf) *        zf  * h01 +
+               xf  *        zf  * h11;
+}
+
+void CHeightMipmap::HalfResizeUpdate(SMipmap &out_mipmap, size_t mapSize, const u16* ptr, size_t left, size_t bottom, size_t right, size_t top)
+{
+    // specialized, faster version of BilinearUpdate for powers of 2 
+
+    ENSURE(out_mipmap.m_MapSize != 0);
+
+    if (out_mipmap.m_MapSize * 2 != mapSize)
+        debug_warn(L"wrong size");
+
+    // valid update window
+    ENSURE(left < out_mipmap.m_MapSize );
+    ENSURE(bottom < out_mipmap.m_MapSize );
+    ENSURE(right > left && right <= out_mipmap.m_MapSize );
+    ENSURE(top > bottom && top <= out_mipmap.m_MapSize );
+
+    for (size_t dstZ = bottom; dstZ < top; ++dstZ)
+    for (size_t dstX = left; dstX < right; ++dstX) 
+    {
+        size_t srcX = dstX << 1;
+        size_t srcZ = dstZ << 1;
+
+        u16 h00 = ptr[srcX + 0 + srcZ * mapSize];
+        u16 h10 = ptr[srcX + 1 + srcZ * mapSize];
+        u16 h01 = ptr[srcX + 0 + (srcZ + 1) * mapSize];
+        u16 h11 = ptr[srcX + 1 + (srcZ + 1) * mapSize];
+        
+        out_mipmap.m_Heightmap[dstX + dstZ * out_mipmap.m_MapSize] = (h00 + h10 + h01 + h11) / 4;
+    }
+}
+
+void CHeightMipmap::BilinearUpdate(SMipmap &out_mipmap, size_t mapSize, const u16* ptr, size_t left, size_t bottom, size_t right, size_t top)
+{
+    ENSURE(out_mipmap.m_MapSize != 0);
+
+    // filter should have full coverage
+    ENSURE(out_mipmap.m_MapSize <= mapSize && out_mipmap.m_MapSize * 2 >= mapSize);
+
+    // valid update window
+    ENSURE(left < out_mipmap.m_MapSize );
+    ENSURE(bottom < out_mipmap.m_MapSize );
+    ENSURE(right > left && right <= out_mipmap.m_MapSize );
+    ENSURE(top > bottom && top <= out_mipmap.m_MapSize );
+
+    if (out_mipmap.m_MapSize * 2 == mapSize) 
+    {
+        // optimized for powers of 2
+        HalfResizeUpdate(out_mipmap, mapSize, ptr, left, bottom, right, top);
+    }
+    else 
+    {
+        for (size_t dstZ = bottom; dstZ < top; ++dstZ)
+        for (size_t dstX = left; dstX < right; ++dstX) {
+            const float x = ((float)dstX / (float)out_mipmap.m_MapSize) * mapSize;
+            const float z = ((float)dstZ / (float)out_mipmap.m_MapSize) * mapSize;
+
+            const size_t srcX = clamp<size_t>( (size_t)x, 0, mapSize - 1);
+            const size_t srcZ = clamp<size_t>( (size_t)z, 0, mapSize - 1);
+
+            const float fx = clamp<float>(x - srcX, 0.0f, 1.0f);
+            const float fz = clamp<float>(z - srcZ, 0.0f, 1.0f);
+
+            const float h00 = ptr[srcX + 0 + srcZ * mapSize];
+            const float h10 = ptr[srcX + 1 + srcZ * mapSize];
+            const float h01 = ptr[srcX + 0 + (srcZ + 1) * mapSize];
+            const float h11 = ptr[srcX + 1 + (srcZ + 1) * mapSize];
+            
+            out_mipmap.m_Heightmap[dstX + dstZ * out_mipmap.m_MapSize] = (u16)
+                ((1.f - fx) * (1.f - fz) * h00 +
+                        fx  * (1.f - fz) * h10 +
+                 (1.f - fx) *        fz  * h01 +
+                        fx  *        fz  * h11);
+        }
+    }
+}

source/graphics/HeightMipmap.h

@@ +1 @@
+/* Copyright (C) 2011 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+/*
+ * Describes ground using heightmap mipmaps
+ * Used for camera movement
+ */
+
+#ifndef INCLUDED_HEIGHTMIPMAP
+#define INCLUDED_HEIGHTMIPMAP
+
+#include <cmath>
+#include "maths/MathUtil.h"
+#include "ps/CLogger.h"
+#include "ps/Profile.h"
+
+struct SMipmap
+{
+    SMipmap()
+    {
+        m_MapSize = 0;
+        m_Heightmap = 0;
+    };
+
+    SMipmap(size_t MapSize,u16* Heightmap) : m_MapSize(MapSize), m_Heightmap(Heightmap)
+    {}
+
+    size_t m_MapSize;
+    u16* m_Heightmap;
+};
+
+class CHeightMipmap
+{
+    NONCOPYABLE(CHeightMipmap);
+public:
+
+    CHeightMipmap();
+    ~CHeightMipmap();
+
+    void Initialize(size_t mapSize, const u16* ptr);
+    void ReleaseData();
+
+    // update (a rectangular piece of) the heightmap mipmaps
+    void Update(const u16* ptr);
+    void Update(const u16* ptr, size_t left, size_t bottom, size_t right, size_t top);
+    
+    float GetTrilinearGroundLevel(float x, float z, float radius) const;
+
+private:
+
+    // get bilinear filtered height from mipmap
+    float BilinearFilter(const SMipmap &mipmap, float x, float z) const;
+        
+    // update rectangle of the output mipmap by bilinear interpolating an input mipmap of exactly twice its size
+    void HalfResizeUpdate(SMipmap &out_mipmap, size_t mapSize, const u16* ptr, size_t left, size_t bottom, size_t right, size_t top);
+    
+    // update rectangle of the output mipmap by bilinear interpolating the input mipmap
+    void BilinearUpdate(SMipmap &out_mipmap, size_t mapSize, const u16* ptr, size_t left, size_t bottom, size_t right, size_t top);
+    
+    // size of this map in each direction
+    size_t m_MapSize;
+
+    // mipmap list
+    std::vector<SMipmap> m_Mipmap;
+
+};
+
+#endif
+ No newline at end of file

source/graphics/Terrain.cpp

@@ -57 +57 @@
 // ReleaseData: delete any data allocated by this terrain
 void CTerrain::ReleaseData()
 {
+    m_HeightMipmap.ReleaseData();
+
     delete[] m_Heightmap;
     delete[] m_Patches;
 }
@@ -89 +91 @@
     // setup patch parents, indices etc
     InitialisePatches();
 
+    // initialise mipmap
+    m_HeightMipmap.Initialize(m_MapSize,m_Heightmap);
+
     return true;
 }
 
@@ -330 +335 @@
     return fixed::FromInt(delta / TERRAIN_TILE_SIZE) / (int)HEIGHT_UNITS_PER_METRE;
 }
 
+float CTerrain::GetFilteredGroundLevel(float x, float z, float radius) const
+{
+    // convert to [0,1] interval
+    float nx = x / (TERRAIN_TILE_SIZE*m_MapSize);
+    float nz = z / (TERRAIN_TILE_SIZE*m_MapSize);
+    float nr = radius / (TERRAIN_TILE_SIZE*m_MapSize);
+
+    // get trilinear filtered mipmap height
+    return HEIGHT_SCALE * m_HeightMipmap.GetTrilinearGroundLevel(nx, nz, nr);
+}
+
 float CTerrain::GetExactGroundLevel(float x, float z) const
 {
     // Clamp to size-2 so we can use the tiles (xi,zi)-(xi+1,zi+1)
@@ -530 +546 @@
 
     // initialise all the new patches
     InitialisePatches();
+
+    // initialise mipmap
+    m_HeightMipmap.Initialize(m_MapSize,m_Heightmap);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -560 +579 @@
             patch->SetDirty(RENDERDATA_UPDATE_VERTICES);
         }
     }
+
+    // update mipmap
+    m_HeightMipmap.Update(m_Heightmap);
 }
 
 
@@ -589 +611 @@
         }
     }
 
+    // update mipmap
+    m_HeightMipmap.Update(m_Heightmap,tx0,tz0,tx1,tz1);
+
     MakeDirty(tx0, tz0, tx1, tz1, RENDERDATA_UPDATE_VERTICES);
 
     return avgY*HEIGHT_SCALE;

source/graphics/Terrain.h

@@ -25 +25 @@
 #include "maths/Vector3D.h"
 #include "maths/Fixed.h"
 #include "graphics/SColor.h"
+#include "graphics/HeightMipmap.h"
 
 class CPatch;
 class CMiniPatch;
@@ -84 +85 @@
     fixed GetVertexGroundLevelFixed(ssize_t i, ssize_t j) const;
     float GetExactGroundLevel(float x, float z) const;
     fixed GetExactGroundLevelFixed(fixed x, fixed z) const;
+    float GetFilteredGroundLevel(float x, float z, float radius) const;
 
     // get the approximate slope (0 = horizontal, 0.5 = 30 degrees, 1.0 = 45 degrees, etc)
     fixed GetSlopeFixed(ssize_t i, ssize_t j) const;
@@ -164 +166 @@
     u16* m_Heightmap;
     // base colour (usually white)
     SColor4ub m_BaseColour;
+    // heightmap mipmap
+    CHeightMipmap m_HeightMipmap;
 };
 
 #endif

source/lib/bits.h

@@ -246 +246 @@
 }
 
 /**
+ * round down to next larger power of two.
+ **/
+template<typename T>
+inline T round_down_to_pow2(T x)
+{
+    return T(1) << floor_log2(x);
+}
+
+/**
  * round number up/down to the next given multiple.
  *
  * @param n Number to round.