Reworked TiledModelLayer to create the SimplePager

in the base class and only require subclasses to implement
createTileImplementation instead of requiring them
to make their own pager.
Added CompositeTiledModelLayer that allows you to merge
multipe TiledModelLayers into a single layer.

src/osgEarth/CMakeLists.txt

@@ -114,6 +114,7 @@ SET(LIB_PUBLIC_HEADERS
     ColorFilter
     Common
     Composite
+    CompositeTiledModelLayer
     Config
     Containers
     Coverage
@@ -260,7 +261,6 @@ SET(LIB_PUBLIC_HEADERS
     TileHandler
     TileMesher
     TileRasterizer
-    TiledFeatureModelGraph
     TiledFeatureModelLayer
     TiledModelLayer
     TileSource
@@ -283,7 +283,6 @@ SET(LIB_PUBLIC_HEADERS
     WMS
     XmlUtils
     XYZ
-    XYZModelGraph
     XYZModelLayer
 
     ActivityMonitorTool
@@ -551,6 +550,7 @@ set(TARGET_SRC
     Color.cpp
     ColorFilter.cpp
     Composite.cpp
+    CompositeTiledModelLayer.cpp
     Compressors.cpp
     Config.cpp
     CoverageLayer.cpp
@@ -676,7 +676,6 @@ set(TARGET_SRC
     TileHandler.cpp
     TileMesher.cpp
     TileRasterizer.cpp
-    TiledFeatureModelGraph.cpp
     TiledFeatureModelLayer.cpp
     TiledModelLayer.cpp
     TileVisitor.cpp
@@ -699,7 +698,6 @@ set(TARGET_SRC
     WMS.cpp
     XmlUtils.cpp
     XYZ.cpp
-    XYZModelGraph.cpp
     XYZModelLayer.cpp
 
     ActivityMonitorTool.cpp

src/osgEarth/CompositeTiledModelLayer

@@ -0,0 +1,95 @@
+/* -*-c++-*- */
+/* osgEarth - Geospatial SDK for OpenSceneGraph
+ * Copyright 2020 Pelican Mapping
+ * http://osgearth.org
+ *
+ * osgEarth is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ */
+#ifndef OSGEARTH_COMPOSITE_TILED_MODEL_LAYER
+#define OSGEARTH_COMPOSITE_TILED_MODEL_LAYER 1
+
+#include <osgEarth/Common>
+#include <osgEarth/Layer>
+#include <osgEarth/TiledModelLayer>
+
+namespace osgEarth {
+    class Map;
+}
+
+namespace osgEarth
+{  
+    class OSGEARTH_EXPORT CompositeTiledModelLayer : public TiledModelLayer
+    {
+    public: // serialization
+        struct OSGEARTH_EXPORT Options : public TiledModelLayer::Options                         
+        {
+            META_LayerOptions(osgEarth, Options, TiledModelLayer::Options);            
+            OE_OPTION(ProfileOptions, profile);
+
+            OE_OPTION_VECTOR(ConfigOptions, layers);
+
+            Config getConfig() const override;
+            void fromConfig(const Config& conf);
+        };
+
+    public:
+        META_Layer(osgEarth, CompositeTiledModelLayer, Options, TiledModelLayer, CompositeTiledModel);
+
+        //! Tiling profile (required)
+        void setProfile(const Profile* profile);
+        const Profile* getProfile() const override { return _profile.get(); }
+
+        unsigned getMinLevel() const override;
+
+        //! Maximum level of detail to access
+        unsigned getMaxLevel() const override;
+
+    public: // Layer
+
+        //! opens the layer and returns the status
+        Status openImplementation() override;
+
+        //! Serialization
+        Config getConfig() const override;
+
+    public: // Layer
+
+        //! called by the map when this layer is added
+        void addedToMap(const Map*) override;
+
+        //! called by the map when this layer is removed
+        void removedFromMap(const Map*) override;
+
+    protected: // TiledModelLayer
+
+        //! Creates an OSG node from a tile key.
+        osg::ref_ptr<osg::Node> createTileImplementation(const TileKey&, ProgressCallback*) const override;
+
+    protected:
+
+        virtual ~CompositeTiledModelLayer();
+
+    private:        
+        osg::ref_ptr<const Profile> _profile;
+        osg::observer_ptr< const Map > _map;
+
+        unsigned int _minLevel = 0;
+        unsigned int _maxLevel = 0;
+
+        std::vector< osg::ref_ptr< TiledModelLayer > > _layers;
+    };
+
+} // namespace osgEarth
+
+#endif // OSGEARTH_COMPOSITE_TILED_MODEL_LAYER

src/osgEarth/CompositeTiledModelLayer.cpp

@@ -0,0 +1,191 @@
+/* -*-c++-*- */
+/* osgEarth - Geospatial SDK for OpenSceneGraph
+ * Copyright 2020 Pelican Mapping
+ * http://osgearth.org
+ *
+ * osgEarth is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ */
+#include <osgEarth/CompositeTiledModelLayer>
+#include <osgEarth/NodeUtils>
+#include <osgEarth/SimplePager>
+
+#include <vector>
+
+using namespace osgEarth;
+
+#define LC "[CompositeTiledModelLayer] "
+
+#define OE_TEST OE_NULL
+
+REGISTER_OSGEARTH_LAYER(CompositeTiledModel, CompositeTiledModelLayer);
+
+void CompositeTiledModelLayer::Options::fromConfig(const Config& conf)
+{
+    conf.get("profile", profile());
+
+    const ConfigSet& layers = conf.child("layers").children();
+    for (ConfigSet::const_iterator i = layers.begin(); i != layers.end(); ++i)
+    {
+        _layers.push_back(ConfigOptions(*i));
+    }
+}
+
+Config
+CompositeTiledModelLayer::Options::getConfig() const
+{
+    Config conf = TiledModelLayer::Options::getConfig();
+    conf.set("profile", profile());
+
+    if (_layers.empty() == false)
+    {
+        Config layersConf("layers");
+        for (std::vector<ConfigOptions>::const_iterator i = _layers.begin(); i != _layers.end(); ++i)
+        {
+            layersConf.add(i->getConfig());
+        }
+        conf.set(layersConf);
+    }
+
+    return conf;
+}
+
+//...........................................................................
+
+CompositeTiledModelLayer::~CompositeTiledModelLayer()
+{
+    //NOP
+}
+
+void CompositeTiledModelLayer::setProfile(const Profile* profile)
+{
+    _profile = profile;
+    if (_profile)
+    {
+        options().profile() = profile->toProfileOptions();
+    }
+}
+
+Config
+CompositeTiledModelLayer::getConfig() const
+{
+    Config conf = TiledModelLayer::getConfig();
+    return conf;
+}
+
+Status
+CompositeTiledModelLayer::openImplementation()
+{
+    Status parent = super::openImplementation();
+    if (parent.isError())
+        return parent;
+
+    _profile = Profile::create(*options().profile());
+
+    // Open all the layers
+    for (auto& layerConf : options().layers())
+    {
+        osg::ref_ptr< Layer > layer = Layer::create(layerConf);
+        TiledModelLayer* tiledLayer = dynamic_cast<TiledModelLayer*>(layer.get());
+        if (tiledLayer)
+        {
+            tiledLayer->open();
+            tiledLayer->setReadOptions(getReadOptions());
+            _layers.push_back(tiledLayer);
+        }
+        else
+        {
+            OE_WARN << LC << "Layer is not a TiledModelLayer" << std::endl;
+        }
+    }
+
+    return Status::NoError;
+}
+
+void
+CompositeTiledModelLayer::addedToMap(const Map* map)
+{
+    for (auto& layer : _layers)
+    {
+        layer->addedToMap(map);
+    }
+
+    // Check to make sure the layers are all using the same profile
+    for (auto& layer : _layers)
+    {
+        if (!layer->getProfile()->isEquivalentTo(_profile))
+        {
+            OE_WARN << LC << "Layer " << layer->getName() << " does not have the same profile as the composite layer" << std::endl;
+        }
+    }
+
+    // Compute the min and max levels
+    if (!_layers.empty())
+    {
+        _minLevel = 1000;
+        _maxLevel = 0;
+        for (auto& layer : _layers)
+        {
+            if (layer->getMinLevel() < _minLevel)
+            {
+                _minLevel = layer->getMinLevel();
+            }
+            if (layer->getMaxLevel() > _maxLevel)
+            {
+                _maxLevel = layer->getMaxLevel();
+            }
+        }
+    }
+
+    super::addedToMap(map);
+}
+
+void
+CompositeTiledModelLayer::removedFromMap(const Map* map)
+{
+    super::removedFromMap(map);
+
+    for (auto& layer : _layers)
+    {
+        layer->removedFromMap(map);
+    }
+}
+
+osg::ref_ptr<osg::Node>
+CompositeTiledModelLayer::createTileImplementation(const TileKey& key, ProgressCallback* progress) const
+{
+    osg::ref_ptr<osg::Group> group = new osg::Group();
+
+    for (unsigned int i = 0; i < this->_layers.size(); i++)
+    {
+        osg::ref_ptr<osg::Node> node = this->_layers[i]->createTile(key, progress);
+        if (node.valid())
+        {
+            group->addChild(node);
+        }
+    }
+    return group;
+}
+
+unsigned
+CompositeTiledModelLayer::getMinLevel() const
+{
+    return _minLevel;
+}
+
+unsigned
+CompositeTiledModelLayer::getMaxLevel() const
+{
+    return _maxLevel;
+}
+