small cleanup to shared object etc.

libraries/qml/src/qml/impl/RenderEventHandler.cpp

@@ -49,8 +49,8 @@ bool RenderEventHandler::event(QEvent* e) {
     return QObject::event(e);
 }
 
-RenderEventHandler::RenderEventHandler(SharedObject* shared, QThread* targetThread)
-    : _shared(shared) {
+RenderEventHandler::RenderEventHandler(SharedObject* shared, QThread* targetThread) :
+        _shared(shared) {
     // Create the GL canvas in the same thread as the share canvas
     if (!_canvas.create(SharedObject::getSharedContext())) {
         qFatal("Unable to create new offscreen GL context");
@@ -136,7 +136,8 @@ void RenderEventHandler::qmlRender(bool sceneGraphSync) {
 
     resize();
 
-    {
+
+    if (_currentSize != QSize()) {
         PROFILE_RANGE(render_qml_gl, "render");
         GLuint texture = SharedObject::getTextureCache().acquireTexture(_currentSize);
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, _fbo);
@@ -146,7 +147,7 @@ void RenderEventHandler::qmlRender(bool sceneGraphSync) {
             glClear(GL_COLOR_BUFFER_BIT);
         } else {
             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-            _shared->_quickWindow->setRenderTarget(_fbo, _currentSize);
+            _shared->setRenderTarget(_fbo, _currentSize);
             _shared->_renderControl->render();
         }
         _shared->_lastRenderTime = usecTimestampNow();
@@ -179,7 +180,7 @@ void RenderEventHandler::onQuit() {
             _fbo = 0;
         }
 
-        _shared->shutdownRendering(_canvas, _currentSize);
+        _shared->shutdownRendering(_currentSize);
         _canvas.doneCurrent();
     }
     _canvas.moveToThreadWithContext(qApp->thread());

libraries/qml/src/qml/impl/SharedObject.cpp

@@ -78,7 +78,6 @@ SharedObject::SharedObject() {
     QObject::connect(qApp, &QCoreApplication::aboutToQuit, this, &SharedObject::onAboutToQuit);
 }
 
-
 SharedObject::~SharedObject() {
     // After destroy returns, the rendering thread should be gone
     destroy();
@@ -173,7 +172,6 @@ void SharedObject::setRootItem(QQuickItem* rootItem) {
     QObject::connect(_renderControl, &QQuickRenderControl::renderRequested, this, &SharedObject::requestRender);
     QObject::connect(_renderControl, &QQuickRenderControl::sceneChanged, this, &SharedObject::requestRenderSync);
 #endif
-
 }
 
 void SharedObject::destroy() {
@@ -210,7 +208,7 @@ void SharedObject::destroy() {
     }
     // Block until the rendering thread has stopped
     // FIXME this is undesirable because this is blocking the main thread,
-    // but I haven't found a reliable way to do this only at application 
+    // but I haven't found a reliable way to do this only at application
     // shutdown
     if (_renderThread) {
         _renderThread->wait();
@@ -220,10 +218,8 @@ void SharedObject::destroy() {
 #endif
 }
 
-
 #define SINGLE_QML_ENGINE 0
 
-
 #if SINGLE_QML_ENGINE
 static QQmlEngine* globalEngine{ nullptr };
 static size_t globalEngineRefCount{ 0 };
@@ -344,6 +340,11 @@ void SharedObject::setSize(const QSize& size) {
 #endif
 }
 
+void SharedObject::setMaxFps(uint8_t maxFps) {
+    QMutexLocker locker(&_mutex);
+    _maxFps = maxFps;
+}
+
 bool SharedObject::preRender(bool sceneGraphSync) {
 #ifndef DISABLE_QML
     QMutexLocker lock(&_mutex);
@@ -370,9 +371,9 @@ bool SharedObject::preRender(bool sceneGraphSync) {
     return true;
 }
 
-void SharedObject::shutdownRendering(OffscreenGLCanvas& canvas, const QSize& size) {
+void SharedObject::shutdownRendering(const QSize& size) {
     QMutexLocker locker(&_mutex);
-    if (size != QSize(0, 0)) {
+    if (size != QSize()) {
         getTextureCache().releaseSize(size);
         if (_latestTextureAndFence.first) {
             getTextureCache().releaseTexture(_latestTextureAndFence);
@@ -380,19 +381,17 @@ void SharedObject::shutdownRendering(OffscreenGLCanvas& canvas, const QSize& siz
     }
 #ifndef DISABLE_QML
     _renderControl->invalidate();
-    canvas.doneCurrent();
 #endif
     wake();
 }
 
-bool SharedObject::isQuit() {
+bool SharedObject::isQuit() const {
     QMutexLocker locker(&_mutex);
     return _quit;
 }
 
 void SharedObject::requestRender() {
-    // Don't queue multiple renders
-    if (_renderRequested) {
+    if (_quit) {
         return;
     }
     _renderRequested = true;
@@ -402,18 +401,13 @@ void SharedObject::requestRenderSync() {
     if (_quit) {
         return;
     }
-
-    {
-        QMutexLocker lock(&_mutex);
-        _syncRequested = true;
-    }
-
-    requestRender();
+    _renderRequested = true;
+    _syncRequested = true;
 }
 
 bool SharedObject::fetchTexture(TextureAndFence& textureAndFence) {
     QMutexLocker locker(&_mutex);
-    if (0 == _latestTextureAndFence.first) {
+    if (!_latestTextureAndFence.first) {
         return false;
     }
     textureAndFence = { 0, 0 };
@@ -421,8 +415,7 @@ bool SharedObject::fetchTexture(TextureAndFence& textureAndFence) {
     return true;
 }
 
-void hifi::qml::impl::SharedObject::addToDeletionList(QObject * object)
-{
+void SharedObject::addToDeletionList(QObject* object) {
     _deletionList.append(QPointer<QObject>(object));
 }
 
@@ -469,11 +462,9 @@ void SharedObject::onRender() {
         return;
     }
 
-    QMutexLocker lock(&_mutex);
     if (_syncRequested) {
-        lock.unlock();
         _renderControl->polishItems();
-        lock.relock();
+        QMutexLocker lock(&_mutex);
         QCoreApplication::postEvent(_renderObject, new OffscreenEvent(OffscreenEvent::RenderSync));
         // sync and render request, main and render threads must be synchronized
         wait();
@@ -494,13 +485,11 @@ void SharedObject::onTimer() {
     {
         QMutexLocker locker(&_mutex);
         // Don't queue more than one frame at a time
-        if (0 != _latestTextureAndFence.first) {
+        if (_latestTextureAndFence.first) {
             return;
         }
-    }
 
-    {
-        if (_maxFps == 0) {
+        if (!_maxFps) {
             return;
         }
         auto minRenderInterval = USECS_PER_SECOND / _maxFps;

libraries/qml/src/qml/impl/SharedObject.h

@@ -16,7 +16,6 @@
 
 #include "TextureCache.h"
 
-
 class QWindow;
 class QTimer;
 class QQuickWindow;
@@ -24,7 +23,6 @@ class QQuickItem;
 class QOpenGLContext;
 class QQmlEngine;
 class QQmlContext;
-class OffscreenGLCanvas;
 
 namespace hifi { namespace qml {
 
@@ -51,11 +49,11 @@ public:
     void create(OffscreenSurface* surface);
     void setRootItem(QQuickItem* rootItem);
     void destroy();
-    bool isQuit();
+    bool isQuit() const;
 
     QSize getSize() const;
     void setSize(const QSize& size);
-    void setMaxFps(uint8_t maxFps) { _maxFps = maxFps; }
+    void setMaxFps(uint8_t maxFps);
 
     QQuickWindow* getWindow() { return _quickWindow; }
     QQuickItem* getRootItem() { return _rootItem; }
@@ -72,7 +70,7 @@ private:
     bool event(QEvent* e) override;
 
     bool preRender(bool sceneGraphSync);
-    void shutdownRendering(OffscreenGLCanvas& canvas, const QSize& size);
+    void shutdownRendering(const QSize& size);
     // Called by the render event handler, from the render thread
     void initializeRenderControl(QOpenGLContext* context);
     void releaseTextureAndFence();
@@ -94,31 +92,30 @@ private:
     QList<QPointer<QObject>> _deletionList;
 
     // Texture management
-    TextureAndFence _latestTextureAndFence{ 0, 0 };
-    QQuickItem* _item{ nullptr };
-    QQuickItem* _rootItem{ nullptr };
-    QQuickWindow* _quickWindow{ nullptr };
-    QQmlContext* _qmlContext{ nullptr };
+    TextureAndFence _latestTextureAndFence { 0, 0 };
+    QQuickItem* _rootItem { nullptr };
+    QQuickWindow* _quickWindow { nullptr };
+    QQmlContext* _qmlContext { nullptr };
     mutable QMutex _mutex;
     QWaitCondition _cond;
 
 #ifndef DISABLE_QML
-    QWindow* _proxyWindow{ nullptr };
-    RenderControl* _renderControl{ nullptr };
-    RenderEventHandler* _renderObject{ nullptr };
+    QWindow* _proxyWindow { nullptr };
+    RenderControl* _renderControl { nullptr };
+    RenderEventHandler* _renderObject { nullptr };
 
-    QTimer* _renderTimer{ nullptr };
-    QThread* _renderThread{ nullptr };
+    QTimer* _renderTimer { nullptr };
+    QThread* _renderThread { nullptr };
 #endif
 
-    uint64_t _lastRenderTime{ 0 };
-    QSize _size{ 100, 100 };
-    uint8_t _maxFps{ 60 };
+    uint64_t _lastRenderTime { 0 };
+    QSize _size { 100, 100 };
+    uint8_t _maxFps { 60 };
 
-    bool _renderRequested{ false };
-    bool _syncRequested{ false };
-    bool _quit{ false };
-    bool _paused{ false };
+    bool _renderRequested { false };
+    bool _syncRequested { false };
+    bool _quit { false };
+    bool _paused { false };
 };
 
 }  // namespace impl

libraries/qml/src/qml/impl/TextureCache.h

@@ -35,9 +35,8 @@ public:
     using Size = uint64_t;
 
     struct TextureSet {
-        Size textureSize;
         // The number of surfaces with this size
-        size_t clientCount{ 0 };
+        size_t clientCount { 0 };
         ValueList returnedTextures;
     };
 
@@ -66,7 +65,7 @@ private:
     std::unordered_map<uint32_t, QSize> _textureSizes;
     Mutex _mutex;
     std::list<Value> _returnedTextures;
-    size_t _totalTextureUsage{ 0 };
+    size_t _totalTextureUsage { 0 };
 };
 
 }}}  // namespace hifi::qml::impl