Changeset 6570


Ignore:
Timestamp:
Nov 6, 2016 12:00:27 AM (6 years ago)
Author:
ldelgass
Message:

First pass at porting to new Map layer API

Location:
geovis/branches/rex
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • geovis/branches/rex/Makefile.in

    r6248 r6570  
    33TRACE                   = #yes
    44TRACE_FRAME             = #yes
    5 NEW_ANNOTATION_API      = #yes
    65USE_OFFSCREEN_RENDERING = #yes
    76USE_THREADS             = yes
     
    1110SLEEP_AFTER_QUEUE_FRAME = yes
    1211QUEUE_ONLY_ONE_FRAME    = yes
    13 USE_REX                 = #yes
     12USE_REX                 = yes
    1413
    1514bindir          = @bindir@
     
    9998ifdef TRACE_FRAME
    10099DEFINES         += -DWANT_FRAME
    101 endif
    102 ifdef NEW_ANNOTATION_API
    103 DEFINES         += -DNEW_ANNOTATION_API
    104100endif
    105101ifdef USE_OFFSCREEN_RENDERING
  • geovis/branches/rex/MouseCoordsTool.h

    r6487 r6570  
    4242        TRACE("%g %g %g", mapCoords.x(), mapCoords.y(), mapCoords.z());
    4343        if (_label.valid()) {
    44             if (mapNode->getMap()->getNumElevationLayers() > 0) {
    45                 _label->setText(osgEarth::Stringify()
    46                                 << _prefix
    47                                 <<  _formatter->format(mapCoords)
    48                                 << "\nElev: " << mapCoords.z() << " m");
    49             } else {
    50                 _label->setText(osgEarth::Stringify()
    51                                 << _prefix
    52                                 <<  _formatter->format(mapCoords));
    53             }
     44            _label->setText(osgEarth::Stringify()
     45                            << _prefix
     46                            <<  _formatter->format(mapCoords)
     47                            << "\nElev: " << mapCoords.z() << " m");
    5448        }
    5549        _pt = mapCoords;
  • geovis/branches/rex/Picker.cpp

    r6281 r6570  
    164164         itr != toUnHover.end(); ++itr) {
    165165        hovered.erase(*itr);
    166 #ifndef NEW_ANNOTATION_API
    167         (*itr)->clearDecoration();
    168 #endif
    169166        _renderer->eventuallyRender();
    170167    }
     
    285282            osgEarth::Registry::objectIndex()->get<osgEarth::Annotation::AnnotationNode>(id);
    286283        std::set<osgEarth::Annotation::AnnotationNode*>& hovered = _renderer->getHovered();
    287 #ifndef NEW_ANNOTATION_API
    288         anno->clearDecoration();
    289 #endif
    290284        _renderer->getPlaceNodes()->removeChild(anno);
    291285        if (hovered.find(anno) != hovered.end()) {
  • geovis/branches/rex/Placard.cpp

    r6507 r6570  
    1414#include <osgEarth/Registry>
    1515#include <osgEarth/ShaderGenerator>
    16 #ifdef NEW_ANNOTATION_API
    1716#include <osgEarth/ScreenSpaceLayout>
    1817#include <osgEarthSymbology/BBoxSymbol>
    19 #else
    20 #include <osgEarth/Decluttering>
    21 #endif
    2218#include <osgEarthSymbology/PolygonSymbol>
    2319#include <osgEarthSymbology/TextSymbol>
     
    4541    _padding = (float)(charSize / 2.0);
    4642
    47 #ifdef NEW_ANNOTATION_API
    4843    osgEarth::Symbology::BBoxSymbol *bbs = _textStyle.getOrCreateSymbol<osgEarth::Symbology::BBoxSymbol>();
    4944    bbs->fill() = osgEarth::Symbology::Color(0.75, 0.75, 0.75, 0.75);
    5045    bbs->margin() = _padding;
    51 #else
    52     // Set backdrop quad color as PolygonSymbol fill
    53     osgEarth::Symbology::PolygonSymbol *ps = _textStyle.getOrCreateSymbol<osgEarth::Symbology::PolygonSymbol>();
    54     ps->fill() = osgEarth::Symbology::Color(0.75, 0.75, 0.75, 0.75);
    55 #endif
    5646}
    5747
     
    10898                         const Placard& placardConf,
    10999                         const osgEarth::Features::AttributeTable &attrs) :
    110 #ifdef NEW_ANNOTATION_API
    111100    osgEarth::Annotation::GeoPositionNode(mapNode, position),
    112 #else
    113     osgEarth::Annotation::OrthoNode(mapNode, position),
    114 #endif
    115101    _placardConf(placardConf),
    116102    _attrs(attrs)
     
    160146PlacardNode::init( const osgEarth::Symbology::Style& style )
    161147{
    162 #ifdef NEW_ANNOTATION_API
    163148    osgEarth::ScreenSpaceLayout::activate(this->getOrCreateStateSet());
    164 #endif
    165149    _backdropGeode = new osg::Geode();
    166150    _backdropGeode->setComputeBoundingSphereCallback(new osgEarth::Annotation::ControlPointCallback());
    167 #ifdef NEW_ANNOTATION_API
    168151    getPositionAttitudeTransform()->addChild( _backdropGeode.get() );
    169 #else
    170     getAttachPoint()->addChild(_backdropGeode.get());
    171 #endif
     152
    172153    osg::StateSet* stateSet = _backdropGeode->getOrCreateStateSet();
    173154    stateSet->setAttributeAndModes( new osg::Depth(osg::Depth::ALWAYS, 0, 1, false), 1 );
     
    179160    _geode->setComputeBoundingSphereCallback(new osgEarth::Annotation::ControlPointCallback());
    180161
    181 #ifdef NEW_ANNOTATION_API
    182162    getPositionAttitudeTransform()->addChild( _geode.get() );
    183 #else
    184     getAttachPoint()->addChild( _geode.get() );
    185 #endif
    186163    stateSet = _geode->getOrCreateStateSet();
    187164    stateSet->setAttributeAndModes( new osg::Depth(osg::Depth::ALWAYS, 0, 1, false), 1 );
     
    235212        return;
    236213    }
    237 #ifndef NEW_ANNOTATION_API
    238     this->clearDecoration();
    239 #endif
    240214    _backdropGeode->removeDrawables( 0, _backdropGeode->getNumDrawables() );
    241215
     
    272246        "osgEarth.PlacardNode",
    273247        osgEarth::Registry::stateSetCache() );
    274 #ifdef NEW_ANNOTATION_API
     248
    275249    // Set to max priority to draw on top in decluttering sort
    276250    setPriority(FLT_MAX);
    277251    // setPriority calls updateLayoutData
    278252    //updateLayoutData();
    279 #endif
    280 }
    281 
    282 #ifdef NEW_ANNOTATION_API
     253}
     254
    283255void
    284256PlacardNode::setPriority(float value)
     
    317289    }
    318290}
    319 #else
    320 void
    321 PlacardNode::setAnnotationData( osgEarth::Annotation::AnnotationData* data )
    322 {
    323     osgEarth::Annotation::OrthoNode::setAnnotationData( data );
    324 
    325     if (!_geode.valid())
    326         return;
    327 
    328     // override this method so we can attach the anno data to the drawables.
    329     for(unsigned i=0; i<_geode->getNumDrawables(); ++i)
    330     {
    331         _geode->getDrawable(i)->setUserData( data );
    332     }
    333 }
    334 #endif
    335291
    336292void
    337293PlacardNode::setDynamic( bool dynamic )
    338294{
    339 #ifdef NEW_ANNOTATION_API
    340295    osgEarth::Annotation::GeoPositionNode::setDynamic( dynamic );
    341 #else
    342     osgEarth::Annotation::OrthoNode::setDynamic( dynamic );
    343 #endif
     296
    344297    osgText::Text* d = dynamic_cast<osgText::Text*>(_geode->getDrawable(0));
    345298    if ( d )
     
    356309PlacardNode::getConfig() const
    357310{
    358 #ifdef NEW_ANNOTATION_API
    359311    osgEarth::Config conf = osgEarth::Annotation::GeoPositionNode::getConfig();
    360 #else
    361     osgEarth::Config conf = osgEarth::Annotation::OrthoNode::getConfig();
    362 #endif
     312
    363313    conf.key() = "placard";
    364314
  • geovis/branches/rex/Placard.h

    r6274 r6570  
    1313#include <algorithm>
    1414
    15 #ifdef NEW_ANNOTATION_API
    1615#include <osgEarth/ScreenSpaceLayout>
    1716#include <osgEarthAnnotation/GeoPositionNode>
    18 #else
    19 #include <osgEarthAnnotation/Decoration>
    20 #include <osgEarthAnnotation/OrthoNode>
    21 #endif
    2217#include <osgEarthAnnotation/LabelNode>
    2318#include <osgEarthFeatures/Feature>
     
    9388public:
    9489    META_Node(osgEarthAnnotation, PlacardLabelNode);
    95 #ifndef NEW_ANNOTATION_API
    96     virtual bool accept(osgEarth::Annotation::Decoration* ds, bool enable)
    97     { return ds->apply(*this, enable); }
    98 #endif
     90
    9991    PlacardLabelNode() :
    10092        osgEarth::Annotation::LabelNode()
     
    121113
    122114class PlacardNode :
    123 #ifdef NEW_ANNOTATION_API
    124115public osgEarth::Annotation::GeoPositionNode
    125 #else
    126 public osgEarth::Annotation::OrthoNode
    127 #endif
    128116{
    129117public:
    130118    META_Node(osgEarthAnnotation, PlacardNode);
    131 #ifndef NEW_ANNOTATION_API
    132     virtual bool accept(osgEarth::Annotation::Decoration* ds, bool enable)
    133     { return ds->apply(*this, enable); }
    134 #endif
     119
    135120    PlacardNode() :
    136 #ifdef NEW_ANNOTATION_API
    137121        osgEarth::Annotation::GeoPositionNode()
    138 #else
    139         osgEarth::Annotation::OrthoNode()
    140 #endif
    141122    {}
    142123    PlacardNode(const PlacardNode& other, const osg::CopyOp& op = osg::CopyOp::DEEP_COPY_ALL) :
    143 #ifdef NEW_ANNOTATION_API
    144124        osgEarth::Annotation::GeoPositionNode(other, op),
    145 #else
    146         osgEarth::Annotation::OrthoNode(other, op),
    147 #endif
    148125        _placardConf(other._placardConf)
    149126    {
     
    177154
    178155public: // Ortho|GeoPositionNode override
    179 #ifdef NEW_ANNOTATION_API
    180156    virtual void setPriority(float value);
    181 #else
    182     virtual void setAnnotationData( osgEarth::Annotation::AnnotationData* data );
    183 #endif
     157
    184158    virtual void setDynamic( bool value );
    185159
     
    188162protected:
    189163    void init(const osgEarth::Symbology::Style& style);
    190 #ifdef NEW_ANNOTATION_API
     164
    191165    void updateLayoutData();
    192 #endif
    193166
    194167    std::string                _text;
     
    196169    osg::ref_ptr<osg::Geode>   _geode;
    197170    osg::ref_ptr<osg::Geode>   _backdropGeode;
    198 #ifdef NEW_ANNOTATION_API
    199171    osg::ref_ptr<osgEarth::ScreenSpaceLayoutData> _dataLayout;
    200 #endif
    201172
    202173    Placard _placardConf;
  • geovis/branches/rex/Renderer.cpp

    r6549 r6570  
    6767#include <osgEarthSymbology/IconSymbol>
    6868#include <osgEarthSymbology/LineSymbol>
    69 
    7069#include <osgEarthAnnotation/AnnotationNode>
    7170#include <osgEarthAnnotation/FeatureNode>
    7271#include <osgEarthAnnotation/PlaceNode>
    73 #ifdef NEW_ANNOTATION_API
    7472#include <osgEarth/ScreenSpaceLayout>
    75 #else
    76 #include <osgEarth/Decluttering>
    77 #include <osgEarthAnnotation/HighlightDecoration>
    78 #include <osgEarthAnnotation/ScaleDecoration>
    79 #endif
    8073#include <osgEarthUtil/EarthManipulator>
    8174#include <osgEarthUtil/Sky>
     
    13211314}
    13221315
     1316void Renderer::setLayerOpacity(const char *name, double opacity)
     1317{
     1318    if (!_map.valid()) {
     1319        ERROR("No map");
     1320        return;
     1321    }
     1322    osgEarth::Layer *layer = _map->getLayerByName(name);
     1323    osgEarth::ImageLayer *ilayer = dynamic_cast<osgEarth::ImageLayer *>(layer);
     1324    if (ilayer != NULL) {
     1325        ilayer->setOpacity(opacity);
     1326        _needsRedraw = true;
     1327        return;
     1328    }
     1329    osgEarth::ModelLayer *mlayer = dynamic_cast<osgEarth::ModelLayer *>(layer);
     1330    if (mlayer != NULL) {
     1331        mlayer->setOpacity(opacity);
     1332        _needsRedraw = true;
     1333        return;
     1334    }
     1335    TRACE("Image layer not found: %s", name);
     1336}
     1337
     1338void Renderer::setLayerVisibility(const char *name, bool state)
     1339{
     1340    if (!_map.valid()) {
     1341        ERROR("No map");
     1342        return;
     1343    }
     1344    osgEarth::Layer *layer = _map->getLayerByName(name);
     1345    osgEarth::TerrainLayer *tlayer = dynamic_cast<osgEarth::TerrainLayer *>(layer);
     1346    if (tlayer != NULL) {
     1347        tlayer->setVisible(state);
     1348        _needsRedraw = true;
     1349        return;
     1350    }
     1351    osgEarth::ModelLayer *mlayer = dynamic_cast<osgEarth::ModelLayer *>(layer);
     1352    if (mlayer != NULL) {
     1353        mlayer->setVisible(state);
     1354        _needsRedraw = true;
     1355        return;
     1356    }
     1357    TRACE("Layer not found: %s", name);
     1358}
     1359
     1360void Renderer::moveLayer(const char *name, unsigned int pos)
     1361{
     1362    if (!_map.valid()) {
     1363        ERROR("No map");
     1364        return;
     1365    }
     1366    osgEarth::Layer *layer = _map->getLayerByName(name);
     1367    if (layer != NULL) {
     1368        _map->moveLayer(layer, pos);
     1369        _needsRedraw = true;
     1370    } else {
     1371        TRACE("Layer not found: %s", name);
     1372    }
     1373}
     1374
     1375void Renderer::removeLayer(const char *name)
     1376{
     1377    if (!_map.valid()) {
     1378        ERROR("No map");
     1379        return;
     1380    }
     1381    osgEarth::Layer *layer = _map->getLayerByName(name);
     1382    if (layer != NULL) {
     1383        _map->removeLayer(layer);
     1384        _needsRedraw = true;
     1385    } else {
     1386        TRACE("Layer not found: %s", name);
     1387    }
     1388}
     1389
    13231390bool Renderer::addImageLayer(const char *name,
    13241391                             osgEarth::TileSourceOptions& opts,
     
    13561423    layerOpts.maxLevel() = maxLOD;
    13571424    osg::ref_ptr<osgEarth::ImageLayer> layer = new osgEarth::ImageLayer(layerOpts);
    1358     if (pos < (unsigned int)_map->getNumImageLayers()) {
     1425    if (pos < (unsigned int)getNumImageLayers()) {
    13591426        _map->insertImageLayer(layer.get(), pos);
    13601427    } else {
     
    13771444        return;
    13781445    }
    1379     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1446    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    13801447    if (layer == NULL) {
    13811448        TRACE("Image layer not found: %s", name);
     
    13951462        return;
    13961463    }
    1397     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1464    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    13981465    if (layer == NULL) {
    13991466        TRACE("Image layer not found: %s", name);
     
    14161483        return;
    14171484    }
    1418     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1485    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    14191486    if (layer != NULL) {
    1420         _map->removeImageLayer(layer);
     1487        _map->removeLayer(layer);
    14211488        _needsRedraw = true;
    14221489    } else {
     
    14311498        return;
    14321499    }
    1433     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1500    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    14341501    if (layer != NULL) {
    14351502        _map->moveImageLayer(layer, pos);
     
    14461513        return;
    14471514    }
    1448     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1515    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    14491516    if (layer != NULL) {
    14501517        layer->setOpacity(opacity);
     
    14611528        return;
    14621529    }
    1463     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1530    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    14641531    if (layer != NULL) {
    14651532        layer->setMinVisibleRange(min);
     
    14771544        return;
    14781545    }
    1479     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1546    osgEarth::ImageLayer *layer = _map->getLayerByName<osgEarth::ImageLayer>(name);
    14801547    if (layer != NULL) {
    14811548        layer->setVisible(state);
     
    14921559        return false;
    14931560    }
    1494     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1561    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    14951562    if (layer != NULL) {
    14961563        osgEarth::SequenceControl *seq = layer->getSequenceControl();
     
    15111578        return false;
    15121579    }
    1513     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1580    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    15141581    if (layer != NULL) {
    15151582        osgEarth::SequenceControl *seq = layer->getSequenceControl();
     
    15321599        return false;
    15331600    }
    1534     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1601    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    15351602    if (layer != NULL) {
    15361603        osgEarth::SequenceControl *seq = layer->getSequenceControl();
     
    15531620        return false;
    15541621    }
    1555     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     1622    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    15561623    if (layer != NULL) {
    15571624        osgEarth::SequenceControl *seq = layer->getSequenceControl();
     
    16011668    _map->addElevationLayer(layer);
    16021669    // Map API lacks an insertElevationLayer method, so need to move it
    1603     if (pos < (unsigned int)_map->getNumElevationLayers()) {
     1670    if (pos < (unsigned int)getNumElevationLayers()) {
    16041671        _map->moveElevationLayer(layer, pos);
    16051672    }
     
    16131680        return;
    16141681    }
    1615     osgEarth::ElevationLayer *layer = _map->getElevationLayerByName(name);
     1682    osgEarth::ElevationLayer *layer = getElevationLayerByName(name);
    16161683    if (layer != NULL) {
    1617         _map->removeElevationLayer(layer);
     1684        _map->removeLayer(layer);
    16181685        _needsRedraw = true;
    16191686    } else {
     
    16281695        return;
    16291696    }
    1630     osgEarth::ElevationLayer *layer = _map->getElevationLayerByName(name);
     1697    osgEarth::ElevationLayer *layer = getElevationLayerByName(name);
    16311698    if (layer != NULL) {
    16321699        _map->moveElevationLayer(layer, pos);
     
    16431710        return;
    16441711    }
    1645     osgEarth::ElevationLayer *layer = _map->getElevationLayerByName(name);
     1712    osgEarth::ElevationLayer *layer = getElevationLayerByName(name);
    16461713    if (layer != NULL) {
    16471714        layer->setVisible(state);
     
    16761743    osgEarth::MaskLayer *layer = getTerrainMaskLayerByName(name);
    16771744    if (layer != NULL) {
    1678         _map->removeTerrainMaskLayer(layer);
     1745        _map->removeLayer(layer);
    16791746        _needsRedraw = true;
    16801747    } else {
     
    16911758        _placeNodes = new osg::Group();
    16921759        _placeNodes->setName("Place Nodes");
    1693 #ifdef NEW_ANNOTATION_API
    16941760        osgEarth::ScreenSpaceLayout::activate(_placeNodes->getOrCreateStateSet());
    1695 #else
    1696         osgEarth::Decluttering::setEnabled(_placeNodes->getOrCreateStateSet(), true);
    1697 #endif
    16981761        _annotations->addChild(_placeNodes.get());
    16991762        if (_picker.valid()) {
     
    17351798void Renderer::enablePlacard(const char *layerName, bool state)
    17361799{
    1737     osgEarth::ModelLayer *layer = _map->getModelLayerByName(layerName);
     1800    osgEarth::ModelLayer *layer = getModelLayerByName(layerName);
    17381801    if (layer == NULL) {
    17391802        ERROR("Unknown layer '%s'", layerName);
     
    17451808void Renderer::setPlacardConfig(const Placard& placardConf, const char *layerName)
    17461809{
    1747     osgEarth::ModelLayer *layer = _map->getModelLayerByName(layerName);
     1810    osgEarth::ModelLayer *layer = getModelLayerByName(layerName);
    17481811    if (layer == NULL) {
    17491812        ERROR("Unknown layer '%s'", layerName);
     
    17851848        return;
    17861849    }
    1787     osgEarth::ModelLayer *layer = _map->getModelLayerByName(layerName);
     1850    osgEarth::ModelLayer *layer = getModelLayerByName(layerName);
    17881851    if (layer == NULL) {
    17891852        ERROR("Unknown layer '%s'", layerName);
     
    18151878        for (size_t i = 0; i < visitor.nodes.size(); i++) {
    18161879            osgEarth::Features::FeatureIndex *index = visitor.nodes[i]->getIndex();
    1817 #if OSGEARTH_MIN_VERSION_REQUIRED(3, 0, 0)
    18181880            osgEarth::ObjectID id = index->getObjectID(fid);
    18191881            if (doPlacard) {
     
    18331895            setHighlightByObjectID(id);
    18341896            TRACE("FID %lu = OID %d", fid, id);
    1835 #endif
    18361897        }
    18371898        _needsRedraw = true;
     
    18761937    PlacardNode *label =
    18771938        new PlacardNode(_mapNode.get(), location, placard, attrs);
    1878 #ifndef NEW_ANNOTATION_API
    1879     label->getOrCreateStateSet()->setRenderBinDetails(INT_MAX, "RenderBin");
    1880 #endif
    18811939    getAnnotations()->addChild(label);
    18821940}
     
    19041962        osg::Node *node = nodes->getChild(i);
    19051963        // This can be Placard, PlacardLabel, Label, Place or Track Node
    1906 #ifdef NEW_ANNOTATION_API
    19071964        if (dynamic_cast<osgEarth::Annotation::GeoPositionNode *>(node) != NULL) {
    1908 #else
    1909         if (dynamic_cast<osgEarth::Annotation::OrthoNode *>(node) != NULL) {
    1910 #endif
    19111965            toRemove.push_back(node);
    19121966        }
     
    19782032    (*geom)[3] = osg::Vec3d(longMin, latMax, 0);
    19792033    node->init();
    1980 #ifndef NEW_ANNOTATION_API
    1981     for (std::set<osgEarth::Annotation::AnnotationNode *>::iterator itr = _selected.begin();
    1982          itr != _selected.end(); ++itr) {
    1983         (*itr)->clearDecoration();
    1984     }
    1985 #endif
    19862034    _selected.clear();
    19872035    SelectPlaceNodesVisitor spnv(this, latMin, latMax, longMin, longMax);
     
    20332081                     pt.x(), pt.y(), placeNode->getName().c_str(),
    20342082                     placeNode->getText().c_str());
    2035 #ifndef NEW_ANNOTATION_API
    2036                 placeNode->setDecoration("select");
    2037 #endif
    20382083            }
    20392084        }
     
    20482093        _selectionBox = NULL;
    20492094    }
    2050 #ifndef NEW_ANNOTATION_API
    2051     for (std::set<osgEarth::Annotation::AnnotationNode *>::iterator itr = _selected.begin();
    2052          itr != _selected.end(); ++itr) {
    2053         (*itr)->clearDecoration();
    2054     }
    2055 #endif
    20562095    _selected.clear();
    20572096    _needsRedraw = true;
     
    23572396    }
    23582397    osgEarth::ModelLayer *layer = new osgEarth::ModelLayer(layerOpts);
    2359     if (pos < (unsigned int)_map->getNumModelLayers()) {
     2398    if (pos < (unsigned int)getNumModelLayers()) {
    23602399        _map->insertModelLayer(layer, pos);
    23612400    } else {
     
    23712410        return;
    23722411    }
    2373     osgEarth::ModelLayer *layer = _map->getModelLayerByName(name);
     2412    osgEarth::ModelLayer *layer = getModelLayerByName(name);
    23742413    if (layer != NULL) {
    2375         _map->removeModelLayer(layer);
     2414        _map->removeLayer(layer);
    23762415        _needsRedraw = true;
    23772416    } else {
     
    23862425        return;
    23872426    }
    2388     osgEarth::ModelLayer *layer = _map->getModelLayerByName(name);
     2427    osgEarth::ModelLayer *layer = getModelLayerByName(name);
    23892428    if (layer != NULL) {
    23902429        _map->moveModelLayer(layer, pos);
     
    24012440        return;
    24022441    }
    2403     osgEarth::ModelLayer *layer = _map->getModelLayerByName(name);
     2442    osgEarth::ModelLayer *layer = getModelLayerByName(name);
    24042443    if (layer != NULL) {
    24052444        layer->setOpacity(opacity);
     
    24162455        return;
    24172456    }
    2418     osgEarth::ModelLayer *layer = _map->getModelLayerByName(name);
     2457    osgEarth::ModelLayer *layer = getModelLayerByName(name);
    24192458    if (layer != NULL) {
    24202459        layer->minVisibleRange(min);
     
    24322471        return;
    24332472    }
    2434     osgEarth::ModelLayer *layer = _map->getModelLayerByName(name);
     2473    osgEarth::ModelLayer *layer = getModelLayerByName(name);
    24352474    if (layer != NULL) {
    24362475        layer->setVisible(state);
     
    26332672        return false;
    26342673    }
    2635     osgEarth::ImageLayer *layer = _map->getImageLayerByName(name);
     2674    osgEarth::ImageLayer *layer = getImageLayerByName(name);
    26362675    if (layer != NULL) {
    26372676        osgEarth::TileSource *ts = layer->getTileSource();
     
    26582697        return false;
    26592698    }
    2660     osgEarth::ElevationLayer *layer = _map->getElevationLayerByName(name);
     2699    osgEarth::ElevationLayer *layer = getElevationLayerByName(name);
    26612700    if (layer != NULL) {
    26622701        osgEarth::TileSource *ts = layer->getTileSource();
     
    27152754        return false;
    27162755    }
    2717     osgEarth::ModelLayer *layer = _map->getModelLayerByName(name);
     2756    osgEarth::ModelLayer *layer = getModelLayerByName(name);
    27182757    if (layer != NULL) {
    27192758        osgEarth::ModelSource *ms = layer->getModelSource();
  • geovis/branches/rex/Renderer.h

    r6549 r6570  
    244244    void setSkyAmbient(float ambientLevel);
    245245
     246    // Generic layer API
     247
     248    void setLayerVisibility(const char *name, bool state);
     249
     250    void setLayerOpacity(const char *name, double opacity);
     251
     252    void removeLayer(const char *name);
     253
     254    void moveLayer(const char *name, unsigned int pos);
     255
    246256    // Image raster layers
    247 
    248257    int getNumImageLayers() const
    249258    {
    250         return (_map.valid() ? _map->getNumImageLayers() : 0);
     259        if (!_map.valid()) return 0;
     260
     261        osgEarth::LayerVector layers;
     262        _map->getLayers(layers);
     263        int count = 0;
     264        osgEarth::LayerVector::const_iterator itr;
     265        for (itr = layers.begin(); itr != layers.end(); ++itr) {
     266            if (dynamic_cast<const osgEarth::ImageLayer *>((*itr).get())) {
     267                count++;
     268            }
     269        }
     270        return count;
    251271    }
    252272
     
    254274    {
    255275        if (_map.valid()) {
    256             osgEarth::ImageLayerVector layerVector;
    257             _map->getImageLayers(layerVector);
    258             osgEarth::ImageLayerVector::const_iterator itr;
     276            osgEarth::LayerVector layerVector;
     277            _map->getLayers(layerVector);
     278            osgEarth::LayerVector::const_iterator itr;
    259279            for (itr = layerVector.begin(); itr != layerVector.end(); ++itr) {
    260                 //osgEarth::UID uid = (*itr)->getUID();
    261                 names.push_back((*itr)->getName());
     280                if (dynamic_cast<const osgEarth::ImageLayer *>((*itr).get())) {
     281                    //osgEarth::UID uid = (*itr)->getUID();
     282                    names.push_back((*itr)->getName());
     283                }
    262284            }
    263285        }
     286    }
     287
     288    osgEarth::ImageLayer *getImageLayerByName(const std::string& name)
     289    {
     290        if (!_map.valid())
     291            return NULL;
     292
     293        return _map->getLayerByName<osgEarth::ImageLayer>(name);
    264294    }
    265295
     
    306336    int getNumElevationLayers() const
    307337    {
    308         return (_map.valid() ? _map->getNumElevationLayers() : 0);
     338        if (!_map.valid()) return 0;
     339
     340        osgEarth::LayerVector layers;
     341        _map->getLayers(layers);
     342        int count = 0;
     343        osgEarth::LayerVector::const_iterator itr;
     344        for (itr = layers.begin(); itr != layers.end(); ++itr) {
     345            if (dynamic_cast<const osgEarth::ElevationLayer *>((*itr).get())) {
     346                count++;
     347            }
     348        }
     349        return count;
    309350    }
    310351
     
    312353    {
    313354        if (_map.valid()) {
    314             osgEarth::ElevationLayerVector layerVector;
    315             _map->getElevationLayers(layerVector);
    316             osgEarth::ElevationLayerVector::const_iterator itr;
     355            osgEarth::LayerVector layerVector;
     356            _map->getLayers(layerVector);
     357            osgEarth::LayerVector::const_iterator itr;
    317358            for (itr = layerVector.begin(); itr != layerVector.end(); ++itr) {
    318                 //osgEarth::UID uid = (*itr)->getUID();
    319                 names.push_back((*itr)->getName());
     359                if (dynamic_cast<osgEarth::ElevationLayer *>((*itr).get())) {
     360                    //osgEarth::UID uid = (*itr)->getUID();
     361                    names.push_back((*itr)->getName());
     362                }
    320363            }
    321364        }
     365    }
     366
     367    osgEarth::ElevationLayer *getElevationLayerByName(const std::string& name)
     368    {
     369        if (!_map.valid())
     370            return NULL;
     371
     372        return _map->getLayerByName<osgEarth::ElevationLayer>(name);
    322373    }
    323374
     
    347398        if (!_map.valid()) return 0;
    348399
    349         osgEarth::MaskLayerVector layers;
    350         _map->getTerrainMaskLayers(layers);
    351         return (int)layers.size();
     400        osgEarth::LayerVector layers;
     401        _map->getLayers(layers);
     402        int count = 0;
     403        osgEarth::LayerVector::const_iterator itr;
     404        for (itr = layers.begin(); itr != layers.end(); ++itr) {
     405            if (dynamic_cast<const osgEarth::MaskLayer *>((*itr).get())) {
     406                count++;
     407            }
     408        }
     409        return count;
    352410    }
    353411
     
    355413    {
    356414        if (_map.valid()) {
    357             osgEarth::MaskLayerVector layerVector;
    358             _map->getTerrainMaskLayers(layerVector);
    359             osgEarth::MaskLayerVector::const_iterator itr;
     415            osgEarth::LayerVector layerVector;
     416            _map->getLayers(layerVector);
     417            osgEarth::LayerVector::const_iterator itr;
    360418            for (itr = layerVector.begin(); itr != layerVector.end(); ++itr) {
    361                 //osgEarth::UID uid = (*itr)->getUID();
    362                 names.push_back((*itr)->getName());
     419                if (dynamic_cast<const osgEarth::MaskLayer *>((*itr).get())) {
     420                    //osgEarth::UID uid = (*itr)->getUID();
     421                    names.push_back((*itr)->getName());
     422                }
    363423            }
    364424        }
     
    370430            return NULL;
    371431
    372         osgEarth::MaskLayerVector layerVector;
    373         _map->getTerrainMaskLayers(layerVector);
    374         osgEarth::MaskLayerVector::iterator itr;
    375         for (itr = layerVector.begin(); itr != layerVector.end(); ++itr) {
    376             if ((*itr)->getName() == name) {
    377                 return (*itr).get();
    378             }
    379         }
    380         return NULL;
     432        return _map->getLayerByName<osgEarth::MaskLayer>(name);
    381433    }
    382434
     
    390442
    391443    // Model layers
    392 
    393444    int getNumModelLayers() const
    394445    {
    395         return (_map.valid() ? _map->getNumModelLayers() : 0);
     446        if (!_map.valid()) return 0;
     447
     448        osgEarth::LayerVector layers;
     449        _map->getLayers(layers);
     450        int count = 0;
     451        osgEarth::LayerVector::const_iterator itr;
     452        for (itr = layers.begin(); itr != layers.end(); ++itr) {
     453            if (dynamic_cast<const osgEarth::ModelLayer *>((*itr).get())) {
     454                count++;
     455            }
     456        }
     457        return count;
    396458    }
    397459
     
    399461    {
    400462        if (_map.valid()) {
    401             osgEarth::ModelLayerVector layerVector;
    402             _map->getModelLayers(layerVector);
    403             osgEarth::ModelLayerVector::const_iterator itr;
     463            osgEarth::LayerVector layerVector;
     464            _map->getLayers(layerVector);
     465            osgEarth::LayerVector::const_iterator itr;
    404466            for (itr = layerVector.begin(); itr != layerVector.end(); ++itr) {
    405                 //osgEarth::UID uid = (*itr)->getUID();
    406                 names.push_back((*itr)->getName());
     467                if (dynamic_cast<const osgEarth::ModelLayer *>((*itr).get())) {
     468                    //osgEarth::UID uid = (*itr)->getUID();
     469                    names.push_back((*itr)->getName());
     470                }
    407471            }
    408472        }
     473    }
     474
     475    osgEarth::ModelLayer *getModelLayerByName(const std::string& name)
     476    {
     477        if (!_map.valid())
     478            return NULL;
     479
     480        return _map->getLayerByName<osgEarth::ModelLayer>(name);
    409481    }
    410482
  • geovis/branches/rex/RendererCmd.cpp

    r6562 r6570  
    27402740    if (objc > 3) {
    27412741        char *name = Tcl_GetString(objv[3]);
    2742         g_renderer->removeImageLayer(name);
    2743         g_renderer->removeElevationLayer(name);
    2744         g_renderer->removeTerrainMaskLayer(name);
    2745         g_renderer->removeModelLayer(name);
     2742        g_renderer->removeLayer(name);
    27462743    } else {
    27472744        g_renderer->clearMap();
     
    27652762        return TCL_ERROR;
    27662763    }
    2767     g_renderer->moveImageLayer(name, (unsigned int)pos);
    2768     g_renderer->moveElevationLayer(name, (unsigned int)pos);
    2769     g_renderer->moveModelLayer(name, (unsigned int)pos);
     2764    g_renderer->moveLayer(name, (unsigned int)pos);
    27702765
    27712766    return TCL_OK;
     
    27862781        return TCL_ERROR;
    27872782    }
    2788     g_renderer->setImageLayerOpacity(name, opacity);
    2789     g_renderer->setModelLayerOpacity(name, opacity);
     2783    g_renderer->setLayerOpacity(name, opacity);
    27902784
    27912785    return TCL_OK;
     
    28562850    if (objc > 4) {
    28572851        char *name = Tcl_GetString(objv[4]);
    2858         g_renderer->setImageLayerVisibility(name, visible);
    2859         g_renderer->setElevationLayerVisibility(name, visible);
    2860         g_renderer->setModelLayerVisibility(name, visible);
     2852        g_renderer->setLayerVisibility(name, visible);
    28612853    } else {
    28622854        std::vector<std::string> layers;
     
    28662858        for (std::vector<std::string>::iterator itr = layers.begin();
    28672859             itr != layers.end(); ++itr) {
    2868             g_renderer->setImageLayerVisibility(itr->c_str(), visible);
    2869             g_renderer->setElevationLayerVisibility(itr->c_str(), visible);
    2870             g_renderer->setModelLayerVisibility(itr->c_str(), visible);
     2860            g_renderer->setLayerVisibility(itr->c_str(), visible);
    28712861        }
    28722862    }
Note: See TracChangeset for help on using the changeset viewer.