ground/gcs/src/libs/osgearth/osgQtQuick/OSGSkyNode.cpp

   1 /**
   2  ******************************************************************************
   3  *
   4  * @file       OSGSkyNode.cpp
   5  * @author     The LibrePilot Project, http://www.librepilot.org Copyright (C) 2016.
   6  * @addtogroup
   7  * @{
   8  * @addtogroup
   9  * @{
  10  * @brief
  11  *****************************************************************************/
  12 /*
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 3 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful, but
  19  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  20  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  21  * for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License along
  24  * with this program; if not, write to the Free Software Foundation, Inc.,
  25  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26  */
  27
  28 #include "OSGSkyNode.hpp"
  29
  30 #include "OSGViewport.hpp"
  31
  32 #include <osgViewer/View>
  33
  34 #include <osgEarth/Config>
  35 #include <osgEarth/DateTime>
  36 #include <osgEarth/MapNode>
  37 #include <osgEarthUtil/Sky>
  38
  39 // #include <osgEarthDrivers/sky_silverlining/SilverLiningOptions>
  40
  41 #include <QDebug>
  42
  43 namespace osgQtQuick {
  44 enum DirtyFlag { Scene = 1 << 0, Viewport = 1 << 1, DateTime = 1 << 2, Light = 1 << 3 };
  45
  46 struct OSGSkyNode::Hidden : public QObject {
  47     Q_OBJECT
  48
  49 private:
  50     OSGSkyNode * const self;
  51
  52     osg::ref_ptr<osgEarth::Util::SkyNode> skyNode;
  53
  54 public:
  55     OSGNode     *sceneNode;
  56     OSGViewport *viewport;
  57
  58     bool        sunLightEnabled;
  59     QDateTime   dateTime;
  60     double      minimumAmbientLight;
  61
  62     Hidden(OSGSkyNode *self) : QObject(self), self(self), sceneNode(NULL), viewport(NULL),
  63         sunLightEnabled(true), minimumAmbientLight(0.03)
  64     {
  65         dateTime = QDateTime::currentDateTime();
  66     }
  67
  68     ~Hidden()
  69     {}
  70
  71     bool acceptSceneNode(OSGNode *node)
  72     {
  73         // qDebug() << "OSGSkyNode::acceptSceneNode" << node;
  74         if (sceneNode == node) {
  75             return false;
  76         }
  77
  78         if (sceneNode) {
  79             disconnect(sceneNode);
  80         }
  81
  82         sceneNode = node;
  83
  84         if (sceneNode) {
  85             connect(sceneNode, &OSGNode::nodeChanged, this, &OSGSkyNode::Hidden::onSceneNodeChanged);
  86         }
  87
  88         return true;
  89     }
  90
  91     void updateScene()
  92     {
  93         if (!sceneNode || !sceneNode->node()) {
  94             qWarning() << "OSGSkyNode::updateScene - scene node not valid";
  95             self->setNode(NULL);
  96             return;
  97         }
  98         // qDebug() << "OSGSkyNode::updateScene - scene node" << sceneNode->node();
  99         osgEarth::MapNode *mapNode = osgEarth::MapNode::findMapNode(sceneNode->node());
 100         if (!mapNode) {
 101             qWarning() << "OSGSkyNode::updateScene - scene node does not contain a map node";
 102             self->setNode(NULL);
 103             return;
 104         }
 105         if (!mapNode->getMap()->isGeocentric()) {
 106             qWarning() << "OSGSkyNode::updateScene - map node is not geocentric";
 107             self->setNode(NULL);
 108             return;
 109         }
 110
 111         // create sky node
 112         if (!skyNode.valid()) {
 113             skyNode = createSimpleSky(mapNode);
 114             // skyNode = createSilverLiningSky(mapNode);
 115
 116             // Ocean
 117             // const osgEarth::Config & externals = mapNode->externalConfig();
 118             // if (externals.hasChild("ocean")) {
 119             // s_ocean = osgEarth::Util::OceanNode::create(osgEarth::Util::OceanOptions(externals.child("ocean")), mapNode);
 120             // if (s_ocean) root->addChild(s_ocean);
 121
 122             skyNode->addChild(sceneNode->node());
 123             self->setNode(skyNode);
 124         } else {
 125             skyNode->removeChild(0, 1);
 126             skyNode->addChild(sceneNode->node());
 127             // self->emitNodeChanged();
 128         }
 129     }
 130
 131     osgEarth::Util::SkyNode *createSimpleSky(osgEarth::MapNode *mapNode)
 132     {
 133         return osgEarth::Util::SkyNode::create(mapNode);
 134     }
 135
 136 /*
 137     osgEarth::Util::SkyNode *createSilverLiningSky(osgEarth::MapNode *mapNode)
 138     {
 139         osgEarth::Drivers::SilverLining::SilverLiningOptions skyOptions;
 140         skyOptions.user() = "OpenPilot";
 141         skyOptions.licenseCode() = "1f02040d24000f0e18";
 142         skyOptions.resourcePath() = "D:/Projects/OpenPilot/3rdparty/SilverLining-SDK-FullSource/Resources";
 143         skyOptions.drawClouds() = true;
 144         skyOptions.cloudsMaxAltitude() = 10000.0;
 145
 146         osgEarth::Util::SkyNode *skyNode = osgEarth::Util::SkyNode::create(skyOptions, mapNode);
 147
 148         return skyNode;
 149     }
 150  */
 151
 152     void updateViewport()
 153     {
 154         // qDebug() << "OSGSkyNode::updateViewport" << skyNode;
 155         if (!skyNode.valid()) {
 156             qWarning() << "OSGSkyNode::updateViewport - invalid sky node" << skyNode;
 157             return;
 158         }
 159         // qDebug() << "OSGSkyNode::updateViewport - attaching to" << viewport->asView();
 160         skyNode->attach(viewport->asView());
 161     }
 162
 163     void updateSunLightEnabled()
 164     {
 165         if (!skyNode.valid()) {
 166             qWarning() << "OSGSkyNode::updateSunLightEnabled - invalid sky node";
 167             return;
 168         }
 169         if (!skyNode.valid()) {
 170             return;
 171         }
 172         // skyNode->setLighting(sunLightEnabled ? osg::StateAttribute::ON : osg::StateAttribute::OFF);
 173     }
 174
 175     void updateDateTime()
 176     {
 177         if (!skyNode.valid()) {
 178             qWarning() << "OSGSkyNode::updateDateTime - invalid sky node";
 179             return;
 180         }
 181         if (!dateTime.isValid()) {
 182             qWarning() << "OSGSkyNode::updateDateTime - invalid date/time" << dateTime;
 183         }
 184
 185         QDate date   = dateTime.date();
 186         QTime time   = dateTime.time();
 187         double hours = time.hour() + (double)time.minute() / 60.0 + (double)time.second() / 3600.0;
 188         skyNode->setDateTime(osgEarth::DateTime(date.year(), date.month(), date.day(), hours));
 189     }
 190
 191     void updateMinimumAmbientLight()
 192     {
 193         if (!skyNode.valid()) {
 194             qWarning() << "OSGSkyNode::updateMinimumAmbientLight - invalid sky node";
 195             return;
 196         }
 197         double d = minimumAmbientLight;
 198         // skyNode->getSunLight()->setAmbient(osg::Vec4(d, d, d, 1.0f));
 199         skyNode->setMinimumAmbient(osg::Vec4(d, d, d, 1.0f));
 200     }
 201
 202     void attachSkyNode(osgViewer::View *view)
 203     {
 204         if (!skyNode.valid()) {
 205             qWarning() << "OSGSkyNode::attachSkyNode - invalid sky node" << skyNode;
 206             return;
 207         }
 208         skyNode->attach(view);
 209     }
 210
 211     void detachSkyNode(osgViewer::View *view)
 212     {
 213         // TODO find a way to detach the skyNode (?)
 214     }
 215
 216 private slots:
 217     void onSceneNodeChanged(osg::Node *node)
 218     {
 219         // qDebug() << "OSGSkyNode::onSceneNodeChanged" << node;
 220         updateScene();
 221     }
 222 };
 223
 224 /* class OSGSkyNode */
 225
 226 OSGSkyNode::OSGSkyNode(QObject *parent) : Inherited(parent), h(new Hidden(this))
 227 {
 228     setDirty(DateTime | Light);
 229 }
 230
 231 OSGSkyNode::~OSGSkyNode()
 232 {
 233     delete h;
 234 }
 235
 236 OSGNode *OSGSkyNode::sceneNode() const
 237 {
 238     return h->sceneNode;
 239 }
 240
 241 void OSGSkyNode::setSceneNode(OSGNode *node)
 242 {
 243     if (h->acceptSceneNode(node)) {
 244         setDirty(Scene);
 245         emit sceneNodeChanged(node);
 246     }
 247 }
 248
 249 OSGViewport *OSGSkyNode::viewport() const
 250 {
 251     return h->viewport;
 252 }
 253
 254 void OSGSkyNode::setViewport(OSGViewport *viewport)
 255 {
 256     if (h->viewport != viewport) {
 257         h->viewport = viewport;
 258         setDirty(Viewport);
 259         emit viewportChanged(viewport);
 260     }
 261 }
 262
 263 bool OSGSkyNode::sunLightEnabled() const
 264 {
 265     return h->sunLightEnabled;
 266 }
 267
 268 void OSGSkyNode::setSunLightEnabled(bool enabled)
 269 {
 270     if (h->sunLightEnabled != enabled) {
 271         h->sunLightEnabled = enabled;
 272         setDirty(Light);
 273         emit sunLightEnabledChanged(enabled);
 274     }
 275 }
 276
 277 QDateTime OSGSkyNode::dateTime() const
 278 {
 279     return h->dateTime;
 280 }
 281
 282 void OSGSkyNode::setDateTime(QDateTime dateTime)
 283 {
 284     if (h->dateTime != dateTime) {
 285         h->dateTime = dateTime;
 286         setDirty(DateTime);
 287         emit dateTimeChanged(dateTime);
 288     }
 289 }
 290
 291 double OSGSkyNode::minimumAmbientLight() const
 292 {
 293     return h->minimumAmbientLight;
 294 }
 295
 296 void OSGSkyNode::setMinimumAmbientLight(double ambient)
 297 {
 298     if (h->minimumAmbientLight != ambient) {
 299         h->minimumAmbientLight = ambient;
 300         setDirty(Light);
 301         emit minimumAmbientLightChanged(ambient);
 302     }
 303 }
 304
 305 osg::Node *OSGSkyNode::createNode()
 306 {
 307     return NULL;
 308 }
 309
 310 void OSGSkyNode::updateNode()
 311 {
 312     Inherited::updateNode();
 313
 314     if (isDirty(Scene)) {
 315         h->updateScene();
 316     }
 317     if (isDirty(Viewport)) {
 318         h->updateViewport();
 319     }
 320     if (isDirty(Light)) {
 321         h->updateSunLightEnabled();
 322         h->updateMinimumAmbientLight();
 323     }
 324     if (isDirty(DateTime)) {
 325         h->updateDateTime();
 326     }
 327 }
 328 } // namespace osgQtQuick
 329
 330 #include "OSGSkyNode.moc"