diff --git a/externals/libqmf b/externals/libqmf
index 9107db5..12bf83b 160000
--- a/externals/libqmf
+++ b/externals/libqmf
@@ -1 +1 @@
-Subproject commit 9107db5eb6351d9b8fac1ec13085c8a08297db78
+Subproject commit 12bf83bcdae705744cfa9aedd15f5369fc5c25f3
diff --git a/mapproxy/src/mapproxy/cesium/cesium.html b/mapproxy/src/mapproxy/cesium/cesium.html
index 564b072..d4c5fb1 100644
--- a/mapproxy/src/mapproxy/cesium/cesium.html
+++ b/mapproxy/src/mapproxy/cesium/cesium.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8">
 
-  <script src="https://cesiumjs.org/releases/1.55/Build/Cesium/Cesium.js"></script>
+  <script src="https://cesiumjs.org/releases/1.56/Build/Cesium/Cesium.js"></script>
   <style>
     @import url(https://cesiumjs.org/releases/1.55/Build/Cesium/Widgets/widgets.css);
     html, body, #cesiumContainer {
diff --git a/mapproxy/src/mapproxy/cesium/cesium.js b/mapproxy/src/mapproxy/cesium/cesium.js
index 678fade..a8d492f 100644
--- a/mapproxy/src/mapproxy/cesium/cesium.js
+++ b/mapproxy/src/mapproxy/cesium/cesium.js
@@ -191,6 +191,16 @@ function processBoundLayer(config, bl) {
 }
 
 function processConfig(config) {
+    if (typeof(config.defaultView !== "undefined")) {
+        // set default rectangle from config
+        Cesium.Camera.DEFAULT_VIEW_FACTOR = 0.0;
+        Cesium.Camera.DEFAULT_VIEW_RECTANGLE
+            = Cesium.Rectangle.fromDegrees(config.defaultView[0]
+                                           , config.defaultView[1]
+                                           , config.defaultView[2]
+                                           , config.defaultView[3]);
+    }
+
     if (config.boundLayer) {
         config.boundLayer = resolveUrl(config.boundLayer, document.URL);
         return loadJson(config.boundLayer, "application/json"
diff --git a/mapproxy/src/mapproxy/gdalsupport.hpp b/mapproxy/src/mapproxy/gdalsupport.hpp
index af3cb07..157cc21 100644
--- a/mapproxy/src/mapproxy/gdalsupport.hpp
+++ b/mapproxy/src/mapproxy/gdalsupport.hpp
@@ -121,6 +121,7 @@ class GdalWarper {
         math::Size2 size;
         geo::GeoDataset::Resampling resampling;
         boost::optional<std::string> mask;
+        boost::optional<double> nodata;
 
         RasterRequest(Operation operation
                       , const std::string &dataset
@@ -135,6 +136,10 @@ class GdalWarper {
             , srs(srs), extents(extents), size(size), resampling(resampling)
             , mask(mask)
         {}
+
+        RasterRequest& setNodata(const boost::optional<double> &value) {
+            nodata = value; return *this;
+        }
     };
 
     Raster warp(const RasterRequest &request, Aborter &sink);
diff --git a/mapproxy/src/mapproxy/gdalsupport/operations.cpp b/mapproxy/src/mapproxy/gdalsupport/operations.cpp
index 090f728..f5b2bd2 100644
--- a/mapproxy/src/mapproxy/gdalsupport/operations.cpp
+++ b/mapproxy/src/mapproxy/gdalsupport/operations.cpp
@@ -71,6 +71,13 @@ cv::Mat* allocateMat(ManagedBuffer &mb
                              , raw + sizeof(cv::Mat));
 }
 
+inline geo::OptionalNodataValue
+asOptNodata(const geo::NodataValue &nodata
+            , const geo::NodataValue &dflt = boost::none)
+{
+    return nodata ? nodata : dflt;
+}
+
 cv::Mat* warpImage(DatasetCache &cache, ManagedBuffer &mb
                    , const std::string &dataset
                    , const geo::SrsDefinition &srs
@@ -78,10 +85,12 @@ cv::Mat* warpImage(DatasetCache &cache, ManagedBuffer &mb
                    , const math::Size2 &size
                    , geo::GeoDataset::Resampling resampling
                    , const boost::optional<std::string> &maskDataset
-                   , bool optimize)
+                   , bool optimize
+                   , const geo::NodataValue &nodata)
 {
     auto &src(cache(dataset));
-    auto dst(geo::GeoDataset::deriveInMemory(src, srs, size, extents));
+    auto dst(geo::GeoDataset::deriveInMemory
+             (src, srs, size, extents, boost::none, asOptNodata(nodata)));
     src.warpInto(dst, resampling);
 
     if (optimize && dst.cmask().empty()) {
@@ -116,10 +125,12 @@ cv::Mat* warpMask(DatasetCache &cache, ManagedBuffer &mb
                   , const math::Extents2 &extents
                   , const math::Size2 &size
                   , geo::GeoDataset::Resampling resampling
-                  , bool optimize)
+                  , bool optimize
+                  , const geo::NodataValue &nodata)
 {
     auto &src(cache(dataset));
-    auto dst(geo::GeoDataset::deriveInMemory(src, srs, size, extents));
+    auto dst(geo::GeoDataset::deriveInMemory
+             (src, srs, size, extents, boost::none, asOptNodata(nodata)));
     src.warpInto(dst, resampling);
 
     // fetch mask from dataset (optimized, all valid -> invalid matrix)
@@ -176,19 +187,22 @@ cv::Mat* warpValueMinMax(DatasetCache &cache, ManagedBuffer &mb
                          , const geo::SrsDefinition &srs
                          , const math::Extents2 &extents
                          , const math::Size2 &size
-                         , geo::GeoDataset::Resampling resampling)
+                         , geo::GeoDataset::Resampling resampling
+                         , const geo::NodataValue &nodata)
 {
     // combined result of warped dataset and result of warpMinMax
     auto &src(cache(dataset));
     auto &minSrc(cache(dataset + ".min"));
     auto &maxSrc(cache(dataset + ".max"));
 
+    const auto nd(asOptNodata(nodata, ForcedNodata));
+
     auto dst(geo::GeoDataset::deriveInMemory
-             (src, srs, size, extents, GDT_Float32, ForcedNodata));
+             (src, srs, size, extents, GDT_Float32, nd));
     auto minDst(geo::GeoDataset::deriveInMemory
-                (minSrc, srs, size, extents, GDT_Float32, ForcedNodata));
+                (minSrc, srs, size, extents, GDT_Float32, nd));
     auto maxDst(geo::GeoDataset::deriveInMemory
-                (maxSrc, srs, size, extents, GDT_Float32, ForcedNodata));
+                (maxSrc, srs, size, extents, GDT_Float32, nd));
 
     geo::GeoDataset::WarpOptions warpOptions;
 #if GDAL_VERSION_NUM >= 2020000
@@ -253,7 +267,8 @@ cv::Mat* warpDem(DatasetCache &cache, ManagedBuffer &mb
                  , const geo::SrsDefinition &srs
                  , const math::Extents2 &extents
                  , const math::Size2 &requestedSize
-                 , bool optimize)
+                 , bool optimize
+                 , const geo::NodataValue &nodata)
 {
     auto &src(cache(dataset));
 
@@ -279,7 +294,7 @@ cv::Mat* warpDem(DatasetCache &cache, ManagedBuffer &mb
     // warp in floats
     auto dst(geo::GeoDataset::deriveInMemory
              (src, srs, gridSize, gridExtents, ::GDT_Float32
-              , ForcedNodata));
+              , asOptNodata(nodata, ForcedNodata)));
 
     auto wri(src.warpInto(dst, geo::GeoDataset::Resampling::dem));
     LOG(info1) << "Warp result: scale=" << wri.scale
@@ -305,13 +320,14 @@ cv::Mat* warp(DatasetCache &cache, ManagedBuffer &mb
         return warpImage
             (cache, mb, req.dataset, req.srs, req.extents, req.size
              , req.resampling, req.mask
-             , (req.operation == Operation::image));
+             , (req.operation == Operation::image), req.nodata);
 
     case Operation::mask:
     case Operation::maskNoOpt:
         return warpMask
             (cache, mb, req.dataset, req.srs, req.extents, req.size
-             , req.resampling, (req.operation == Operation::mask));
+             , req.resampling, (req.operation == Operation::mask)
+             , req.nodata);
 
     case Operation::detailMask:
         return warpDetailMask
@@ -321,12 +337,13 @@ cv::Mat* warp(DatasetCache &cache, ManagedBuffer &mb
     case Operation::demOptimal:
         return warpDem
             (cache, mb, req.dataset, req.srs, req.extents, req.size
-             , (req.operation == Operation::demOptimal));
+             , (req.operation == Operation::demOptimal)
+             , req.nodata);
 
     case Operation::valueMinMax:
         return warpValueMinMax
             (cache, mb, req.dataset, req.srs, req.extents, req.size
-             , req.resampling);
+             , req.resampling, req.nodata);
     }
     throw;
 }
diff --git a/mapproxy/src/mapproxy/gdalsupport/requests.cpp b/mapproxy/src/mapproxy/gdalsupport/requests.cpp
index 3f479ae..4a37c1b 100644
--- a/mapproxy/src/mapproxy/gdalsupport/requests.cpp
+++ b/mapproxy/src/mapproxy/gdalsupport/requests.cpp
@@ -43,6 +43,7 @@ ShRaster::ShRaster(const GdalWarper::RasterRequest &other
     , size_(other.size)
     , resampling_(other.resampling)
     , mask_(sm.get_allocator<char>())
+    , nodata_(other.nodata)
     , response_()
 {
     if (other.mask) {
@@ -60,7 +61,7 @@ ShRaster::operator GdalWarper::RasterRequest() const {
          , std::string(dataset_.data(), dataset_.size())
          , geo::SrsDefinition(asString(srs_), srsType_)
          , extents_, size_, resampling_
-         , asOptional(mask_));
+         , asOptional(mask_)).setNodata(nodata_);
 }
 
 cv::Mat* ShRaster::response() {
diff --git a/mapproxy/src/mapproxy/gdalsupport/requests.hpp b/mapproxy/src/mapproxy/gdalsupport/requests.hpp
index 4937f91..5588a14 100644
--- a/mapproxy/src/mapproxy/gdalsupport/requests.hpp
+++ b/mapproxy/src/mapproxy/gdalsupport/requests.hpp
@@ -67,6 +67,7 @@ class ShRaster : boost::noncopyable {
     math::Size2 size_;
     geo::GeoDataset::Resampling resampling_;
     String mask_;
+    boost::optional<double> nodata_;
 
     // response matrix
     cv::Mat *response_;
diff --git a/mapproxy/src/mapproxy/generator/surface-dem.cpp b/mapproxy/src/mapproxy/generator/surface-dem.cpp
index deb8e48..59f82ee 100644
--- a/mapproxy/src/mapproxy/generator/surface-dem.cpp
+++ b/mapproxy/src/mapproxy/generator/surface-dem.cpp
@@ -330,9 +330,9 @@ class DemSampler {
 
 } // namespace
 
-AugmentedMesh SurfaceDem::generateMeshImpl(const vts::NodeInfo &nodeInfo
-                                           , Sink &sink
-                                           , Arsenal &arsenal) const
+AugmentedMesh SurfaceDem
+::generateMeshImpl(const vts::NodeInfo &nodeInfo, Sink &sink
+                   , Arsenal &arsenal, const OptHeight &defaultHeight) const
 {
     const int samplesPerSide(128);
     const TileFacesCalculator tileFacesCalculator;
@@ -347,6 +347,7 @@ AugmentedMesh SurfaceDem::generateMeshImpl(const vts::NodeInfo &nodeInfo
                , dem_.dataset
                , nodeInfo.srsDef(), nodeInfo.extents()
                , math::Size2(samplesPerSide, samplesPerSide))
+              .setNodata(defaultHeight)
               , sink));
 
     sink.checkAborted();
diff --git a/mapproxy/src/mapproxy/generator/surface-dem.hpp b/mapproxy/src/mapproxy/generator/surface-dem.hpp
index a875c9a..e9adf85 100644
--- a/mapproxy/src/mapproxy/generator/surface-dem.hpp
+++ b/mapproxy/src/mapproxy/generator/surface-dem.hpp
@@ -56,9 +56,9 @@ class SurfaceDem : public SurfaceBase {
                                   , const SurfaceFileInfo &fileInfo
                                   , Arsenal &arsenal) const;
 
-    virtual AugmentedMesh generateMeshImpl(const vts::NodeInfo &nodeInfo
-                                           , Sink &sink
-                                           , Arsenal &arsenal) const;
+    virtual AugmentedMesh
+    generateMeshImpl(const vts::NodeInfo &nodeInfo, Sink &sink
+                     , Arsenal &arsenal, const OptHeight &defaultHeight) const;
 
     virtual void generateNavtile(const vts::TileId &tileId
                                  , Sink &sink
diff --git a/mapproxy/src/mapproxy/generator/surface-spheroid.cpp b/mapproxy/src/mapproxy/generator/surface-spheroid.cpp
index 3d5747f..072aa79 100644
--- a/mapproxy/src/mapproxy/generator/surface-spheroid.cpp
+++ b/mapproxy/src/mapproxy/generator/surface-spheroid.cpp
@@ -476,9 +476,9 @@ void SurfaceSpheroid::generateMetatile(const vts::TileId &tileId
     sink.content(os.str(), fi.sinkFileInfo());
 }
 
-AugmentedMesh SurfaceSpheroid::generateMeshImpl(const vts::NodeInfo &nodeInfo
-                                                , Sink &sink
-                                                , Arsenal&) const
+AugmentedMesh
+SurfaceSpheroid::generateMeshImpl(const vts::NodeInfo &nodeInfo, Sink &sink
+                                  , Arsenal&, const OptHeight&) const
 {
     // TODO: calculate tile sampling
     const int samplesPerSide(10);
diff --git a/mapproxy/src/mapproxy/generator/surface-spheroid.hpp b/mapproxy/src/mapproxy/generator/surface-spheroid.hpp
index 428b80d..b15d263 100644
--- a/mapproxy/src/mapproxy/generator/surface-spheroid.hpp
+++ b/mapproxy/src/mapproxy/generator/surface-spheroid.hpp
@@ -53,7 +53,8 @@ class SurfaceSpheroid : public SurfaceBase {
 
     virtual AugmentedMesh generateMeshImpl(const vts::NodeInfo &nodeInfo
                                            , Sink &sink
-                                           , Arsenal &arsenal) const;
+                                           , Arsenal &arsenal
+                                           , const OptHeight&) const;
 
     virtual void generateNavtile(const vts::TileId &tileId
                                  , Sink &sink
diff --git a/mapproxy/src/mapproxy/generator/surface.cpp b/mapproxy/src/mapproxy/generator/surface.cpp
index 96a3eff..e16c4c1 100644
--- a/mapproxy/src/mapproxy/generator/surface.cpp
+++ b/mapproxy/src/mapproxy/generator/surface.cpp
@@ -620,8 +620,47 @@ void SurfaceBase::generateTerrain(const vts::TileId &tmsTileId
     // remap id from TMS to VTS
     const auto tileId(tms2vts(tms.rootId, tms.flipY, tmsTileId));
 
+    const auto &zerotile([&]() -> bool
+    {
+        // level 0 is always generated
+        if (tmsTileId.lod > 0) {
+            // other non-defined levels are base on tile's presence above
+            // existing tiles (computed in VTS system!)
+            const auto &r(resource());
+            // shift resource's tile range to this lod
+            const auto range
+                (vts::shiftRange(r.lodRange.min, r.tileRange, tileId.lod));
+            // and check for tile's incidence
+            if (!math::inside(range, tileId.x, tileId.y)) { return false; }
+        }
+
+        vts::NodeInfo nodeInfo(referenceFrame(), tileId);
+        if (!nodeInfo.productive()) {
+            utility::raise<NotFound>
+                ("TileId outside of valid reference frame tree.");
+        }
+
+        // some toplevel tile -> zero tile
+        auto lm(meshFromNode(nodeInfo, math::Size2(10, 10)));
+
+        // write mesh to stream (gzipped)
+        std::ostringstream os;
+        qmf::save(qmfMesh(lm.mesh, nodeInfo
+                          , (tms.physicalSrs ? *tms.physicalSrs
+                             : referenceFrame().model.physicalSrs)
+                          , boost::none)
+                  , utility::Gzipper(os), fi.fileInfo.filename);
+
+        auto sfi(fi.sinkFileInfo());
+        sfi.addHeader("Content-Encoding", "gzip");
+        sink.content(os.str(), sfi);
+
+        return true;
+    });
+
     auto flags(index_->tileIndex.get(tileId));
     if (!vts::TileIndex::Flag::isReal(flags)) {
+        if (zerotile()) { return; }
         utility::raise<NotFound>("No terrain for this tile.");
     }
 
@@ -631,8 +670,8 @@ void SurfaceBase::generateTerrain(const vts::TileId &tmsTileId
             ("TileId outside of valid reference frame tree.");
     }
 
-    // generate the actual mesh
-    auto lm(generateMeshImpl(nodeInfo, sink, arsenal));
+    // generate the actual mesh; replace all no-data values with zero
+    auto lm(generateMeshImpl(nodeInfo, sink, arsenal, 0.0));
 
     // write mesh to stream (gzipped)
     std::ostringstream os;
@@ -647,6 +686,61 @@ void SurfaceBase::generateTerrain(const vts::TileId &tmsTileId
     sink.content(os.str(), sfi);
 }
 
+namespace {
+
+struct TerrainBound {
+    LayerJson::Available available;
+    math::Extents2 bounds;
+
+    TerrainBound() : bounds(math::InvalidExtents{}) {}
+};
+
+TerrainBound terrainBounds(const Resource &r, const vre::Tms &tms)
+{
+    TerrainBound tb;
+
+    // ensure we have top-level tiles "available"
+    if (tms.rootId.lod < r.lodRange.min) {
+        tb.available.emplace_back();
+        auto &current(tb.available.back());
+
+        const auto lod(tms.rootId.lod);
+        for (const auto &block : metatileBlocks
+                 (*r.referenceFrame, vts::TileId(lod, 0, 0), lod, false))
+        {
+            const auto tmsRange(vts2tms(tms.rootId, tms.flipY
+                                        , vts::LodTileRange(lod, block.view)));
+            current.push_back(tmsRange.range);
+        }
+    }
+
+    // all other lods between top-level and first data lod are empty
+    for (auto lod(tms.rootId.lod + 1); lod < r.lodRange.min; ++lod) {
+        tb.available.emplace_back();
+    }
+
+    const auto physicalSrs(tms.physicalSrs ? *tms.physicalSrs
+                           : r.referenceFrame->model.physicalSrs);
+    for (const auto &range : vts::Ranges(r.lodRange, r.tileRange).ranges()) {
+        tb.available.emplace_back();
+        auto &current(tb.available.back());
+        const auto tmsRange(vts2tms(tms.rootId, tms.flipY, range));
+        current.push_back(tmsRange.range);
+
+        // treat current LOD as one gigantic metatile
+        for (const auto &block : metatileBlocks(r, vts::TileId(range.lod, 0, 0)
+                                                , range.lod, false))
+        {
+            const vts::CsConvertor conv(block.srs, physicalSrs);
+            math::update(tb.bounds, conv(block.extents));
+        }
+    }
+
+    return tb;
+}
+
+} // namespace
+
 void SurfaceBase::layerJson(Sink &sink, const TerrainFileInfo &fi
                             , const vre::Tms &tms) const
 {
@@ -666,30 +760,12 @@ void SurfaceBase::layerJson(Sink &sink, const TerrainFileInfo &fi
     layer.projection = tms.projection;
 
     // fixed LOD range
-    layer.zoom.min = r.lodRange.min - tms.rootId.lod;
+    layer.zoom.min = 0; // r.lodRange.min - tms.rootId.lod;
     layer.zoom.max = r.lodRange.max - tms.rootId.lod;
 
-    // invalidate extents, updated in this per-lod loop
-    layer.bounds = math::Extents2(math::InvalidExtents{});
-
-    // TODO: use tileindex instead of single tile range; should be OK for now
-    for (const auto &range : vts::Ranges(r.lodRange, r.tileRange).ranges()) {
-        layer.available.emplace_back();
-        auto &current(layer.available.back());
-        const auto tmsRange(vts2tms(tms.rootId, tms.flipY, range));
-        current.push_back(tmsRange.range);
-
-        const auto physicalSrs(tms.physicalSrs ? *tms.physicalSrs
-                               : referenceFrame().model.physicalSrs);
-
-        // treat current LOD as one gigantic metatile
-        for (const auto &block : metatileBlocks(r, vts::TileId(range.lod, 0, 0)
-                                                , range.lod, false))
-        {
-            const vts::CsConvertor conv(block.srs, physicalSrs);
-            math::update(layer.bounds, conv(block.extents));
-        }
-    }
+    auto tb(terrainBounds(r, tms));
+    layer.available = std::move(tb.available);
+    layer.bounds = std::move(tb.bounds);
 
     if (!r.credits.empty()) {
         layer.attribution
@@ -731,6 +807,9 @@ void SurfaceBase::cesiumConf(Sink &sink, const TerrainFileInfo &fi
         conf.boundLayer = blPath.string();
     };
 
+    const auto tb(terrainBounds(resource(), tms));
+    conf.defaultView = tb.bounds;
+
     std::ostringstream os;
     save(conf, os);
     sink.content(os.str(), fi.sinkFileInfo());
diff --git a/mapproxy/src/mapproxy/generator/surface.hpp b/mapproxy/src/mapproxy/generator/surface.hpp
index 8215dca..967262a 100644
--- a/mapproxy/src/mapproxy/generator/surface.hpp
+++ b/mapproxy/src/mapproxy/generator/surface.hpp
@@ -105,9 +105,10 @@ class SurfaceBase : public Generator {
 
     /** Generic mesh generation, used by both surface and terrain interface.
      */
-    virtual AugmentedMesh generateMeshImpl(const vts::NodeInfo &nodeInfo
-                                           , Sink &sink
-                                           , Arsenal &arsenal) const = 0;
+    virtual AugmentedMesh
+    generateMeshImpl(const vts::NodeInfo &nodeInfo
+                     , Sink &sink, Arsenal &arsenal
+                     , const OptHeight &defaultHeight = boost::none) const = 0;
 
     /** Cesium terrain provider support. Generates non-VTS mesh.
      */
diff --git a/mapproxy/src/mapproxy/support/cesiumconf.cpp b/mapproxy/src/mapproxy/support/cesiumconf.cpp
index 221bcd6..601643a 100644
--- a/mapproxy/src/mapproxy/support/cesiumconf.cpp
+++ b/mapproxy/src/mapproxy/support/cesiumconf.cpp
@@ -41,6 +41,13 @@ void build(Json::Value &content, const CesiumConf &conf)
 {
     content = Json::objectValue;
     if (conf.boundLayer) { content["boundLayer"] = *conf.boundLayer; }
+    if (conf.defaultView) {
+        auto &dv(content["defaultView"] = Json::arrayValue);
+        dv.append(conf.defaultView->ll(0));
+        dv.append(conf.defaultView->ll(1));
+        dv.append(conf.defaultView->ur(0));
+        dv.append(conf.defaultView->ur(1));
+    }
     content["tms"] = vre::asJson(conf.tms);
 }
 
diff --git a/mapproxy/src/mapproxy/support/cesiumconf.hpp b/mapproxy/src/mapproxy/support/cesiumconf.hpp
index edc25c3..7d611a0 100644
--- a/mapproxy/src/mapproxy/support/cesiumconf.hpp
+++ b/mapproxy/src/mapproxy/support/cesiumconf.hpp
@@ -47,6 +47,7 @@ struct CesiumConf {
     typedef boost::optional<std::string> OString;
     vre::Tms tms;
     OString boundLayer;
+    boost::optional<math::Extents2> defaultView;
 
     CesiumConf() {}
 };
diff --git a/mapproxy/src/mapproxy/support/mesh.hpp b/mapproxy/src/mapproxy/support/mesh.hpp
index 6b60b4e..066940a 100644
--- a/mapproxy/src/mapproxy/support/mesh.hpp
+++ b/mapproxy/src/mapproxy/support/mesh.hpp
@@ -72,6 +72,8 @@ struct AugmentedMesh {
     AugmentedMesh() : fullyCovered(false), textureLayerId() {}
 };
 
+typedef boost::optional<double> OptHeight;
+
 AugmentedMesh
 meshFromNode(const vts::NodeInfo &nodeInfo, const math::Size2 &edges
              , const HeightSampler &heights = HeightSampler());
diff --git a/mapproxy/src/mapproxy/support/metatile.cpp b/mapproxy/src/mapproxy/support/metatile.cpp
index 40d8f40..4c5a3ab 100644
--- a/mapproxy/src/mapproxy/support/metatile.cpp
+++ b/mapproxy/src/mapproxy/support/metatile.cpp
@@ -211,6 +211,16 @@ MetatileBlock::list metatileBlocks(const Resource &resource
          (resource.lodRange.min, resource.tileRange, tileId.lod));
 }
 
+MetatileBlock::list metatileBlocks(const vr::ReferenceFrame &referenceFrame
+                                   , const vts::TileId &tileId
+                                   , unsigned int metaBinaryOrder
+                                   , bool includeInvalid)
+{
+    return metatileBlocksImpl
+        (referenceFrame, tileId, metaBinaryOrder, includeInvalid
+         , vts::childRange(vts::TileRange(0, 0, 0, 0), tileId.lod));
+}
+
 cv::Mat boundlayerMetatileFromMaskTree(const vts::TileId &tileId
                                        , const MaskTree &maskTree
                                        , const MetatileBlock::list &blocks)
diff --git a/mapproxy/src/mapproxy/support/metatile.hpp b/mapproxy/src/mapproxy/support/metatile.hpp
index 7456c15..01dfa59 100644
--- a/mapproxy/src/mapproxy/support/metatile.hpp
+++ b/mapproxy/src/mapproxy/support/metatile.hpp
@@ -63,7 +63,7 @@ struct MetatileBlock {
 
 /** Generate metatile blocks for given metatile id in given reference frame
  *
- *  \param referenceFrame reference frame
+ *  \param resource resource to get reference frame and tile range bounds
  *  \param tileId metatile id
  *  \param metaBinaryOrder metatile binary order override if nonzero
  */
@@ -72,6 +72,17 @@ MetatileBlock::list metatileBlocks(const Resource &resource
                                    , unsigned int metaBinaryOrder = 0
                                    , bool includeInvalid = false);
 
+/** Generate metatile blocks for given metatile id in given reference frame
+ *
+ *  \param referenceFrame reference frame
+ *  \param tileId metatile id
+ *  \param metaBinaryOrder metatile binary order override if nonzero
+ */
+MetatileBlock::list metatileBlocks(const vr::ReferenceFrame &referenceFrame
+                                   , const vts::TileId &tileId
+                                   , unsigned int metaBinaryOrder = 0
+                                   , bool includeInvalid = false);
+
 inline bool special(const vr::ReferenceFrame &referenceFrame
                     , const vts::TileId &tileId)
 {
