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

   1 /**
   2  ******************************************************************************
   3  *
   4  * @file       OSGFileNode.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 "OSGFileNode.hpp"
  29
  30 #include <osgDB/ReadFile>
  31 #include <osgUtil/Optimizer>
  32
  33 #include <QUrl>
  34 #include <QOpenGLContext>
  35 #include <QThread>
  36 #include <QElapsedTimer>
  37 #include <QDebug>
  38
  39 namespace osgQtQuick {
  40 enum DirtyFlag { Source = 1 << 0, Async = 1 << 1, OptimizeMode = 1 << 2 };
  41
  42 class OSGFileLoader : public QThread {
  43     Q_OBJECT
  44
  45 public:
  46     OSGFileLoader(const QUrl &url) : url(url)
  47     {}
  48
  49     void run()
  50     {
  51         osg::Node *node = load();
  52         emit loaded(url, node);
  53     }
  54
  55     osg::Node *load()
  56     {
  57         QElapsedTimer t;
  58
  59         t.start();
  60         // qDebug() << "OSGFileLoader::load - reading node file" << url.path();
  61         // qDebug() << "OSGFileLoader - load - currentContext" << QOpenGLContext::currentContext();
  62         osg::Node *node = osgDB::readNodeFile(url.path().toStdString());
  63         if (!node) {
  64             qWarning() << "OSGFileLoader::load - failed to load" << url.path();
  65         }
  66         // qDebug() << "OSGFileLoader::load - reading node" << node << "took" << t.elapsed() << "ms";
  67         return node;
  68     }
  69
  70 signals:
  71     void loaded(const QUrl & url, osg::Node *node);
  72
  73 private:
  74     QUrl url;
  75 };
  76
  77 struct OSGFileNode::Hidden : public QObject {
  78     Q_OBJECT
  79
  80 private:
  81     OSGFileNode * const self;
  82
  83 public:
  84     QUrl source;
  85     bool async;
  86     OptimizeMode::Enum optimizeMode;
  87
  88     Hidden(OSGFileNode *self) : QObject(self), self(self), source(), async(false), optimizeMode(OptimizeMode::None)
  89     {}
  90
  91     void updateSource()
  92     {
  93         // qDebug() << "OSGFileNode::updateNode" << source;
  94         if (!source.isValid()) {
  95             self->setNode(NULL);
  96             if (!source.isEmpty()) {
  97                 qWarning() << "OSGFileNode::updateNode - invalid source" << source;
  98             }
  99         }
 100         if (false /*async*/) {
 101             // not supported yet
 102             // it is not clear if thread safety is insured...
 103             asyncLoad(source);
 104         } else {
 105             setNode(syncLoad(source));
 106         }
 107     }
 108
 109 private:
 110     osg::Node *syncLoad(const QUrl &url)
 111     {
 112         OSGFileLoader loader(url);
 113
 114         return loader.load();
 115     }
 116
 117     void asyncLoad(const QUrl &url)
 118     {
 119         OSGFileLoader *loader = new OSGFileLoader(url);
 120
 121         connect(loader, &OSGFileLoader::loaded, this, &Hidden::onLoaded);
 122         connect(loader, &OSGFileLoader::finished, loader, &OSGFileLoader::deleteLater);
 123         loader->start();
 124     }
 125
 126     void setNode(osg::Node *node)
 127     {
 128         // qDebug() << "OSGFileNode::setNode" << node;
 129         if (node && optimizeMode != OptimizeMode::None) {
 130             // qDebug() << "OSGFileNode::acceptNode - optimize" << node << optimizeMode;
 131             osgUtil::Optimizer optimizer;
 132             optimizer.optimize(node, osgUtil::Optimizer::DEFAULT_OPTIMIZATIONS);
 133         }
 134         self->setNode(node);
 135     }
 136
 137 private slots:
 138     void onLoaded(const QUrl &url, osg::Node *node)
 139     {
 140         // called in async mode
 141         // question : is it thread safe to call setNode() ?
 142         // could calling setDirty help? is setDirty() thread safe ?
 143         setNode(node);
 144     }
 145 };
 146
 147 /* class OSGFileNode */
 148
 149 OSGFileNode::OSGFileNode(QObject *parent) : Inherited(parent), h(new Hidden(this))
 150 {}
 151
 152 OSGFileNode::~OSGFileNode()
 153 {
 154     delete h;
 155 }
 156
 157 const QUrl OSGFileNode::source() const
 158 {
 159     return h->source;
 160 }
 161
 162 void OSGFileNode::setSource(const QUrl &source)
 163 {
 164     if (h->source != source) {
 165         h->source = source;
 166         setDirty(Source);
 167         emit sourceChanged(source);
 168     }
 169 }
 170
 171 bool OSGFileNode::async() const
 172 {
 173     return h->async;
 174 }
 175
 176 void OSGFileNode::setAsync(const bool async)
 177 {
 178     if (h->async != async) {
 179         h->async = async;
 180         setDirty(Async);
 181         emit asyncChanged(async);
 182     }
 183 }
 184
 185 OptimizeMode::Enum OSGFileNode::optimizeMode() const
 186 {
 187     return h->optimizeMode;
 188 }
 189
 190 void OSGFileNode::setOptimizeMode(OptimizeMode::Enum optimizeMode)
 191 {
 192     if (h->optimizeMode != optimizeMode) {
 193         h->optimizeMode = optimizeMode;
 194         setDirty(OptimizeMode);
 195         emit optimizeModeChanged(optimizeMode);
 196     }
 197 }
 198
 199 osg::Node *OSGFileNode::createNode()
 200 {
 201     // node is created later
 202     return NULL;
 203 }
 204
 205 void OSGFileNode::updateNode()
 206 {
 207     Inherited::updateNode();
 208
 209     if (isDirty(Async)) {
 210         // do nothing...
 211     }
 212     if (isDirty(OptimizeMode)) {
 213         // TODO: trigger a node update ?
 214     }
 215     if (isDirty(Source)) {
 216         h->updateSource();
 217     }
 218 }
 219 } // namespace osgQtQuick
 220
 221 #include "OSGFileNode.moc"