1 files changed, 89 insertions, 18 deletions

diff --git a/src/datavisualization/utils/objecthelper.cpp b/src/datavisualization/utils/objecthelper.cpp
index 97695193..a66e0f7e 100644
--- a/src/datavisualization/utils/objecthelper.cpp
+++ b/src/datavisualization/utils/objecthelper.cpp
@@ -19,7 +19,6 @@
 #include "meshloader_p.h"
 #include "vertexindexer_p.h"
 #include "objecthelper_p.h"
-#include "abstractobjecthelper_p.h"
 
 QT_BEGIN_NAMESPACE_DATAVISUALIZATION
 
@@ -27,15 +26,87 @@ ObjectHelper::ObjectHelper(const QString &objectFile)
     : m_objectFile(objectFile)
 {
     m_indicesType = GL_UNSIGNED_SHORT;
+    load();
 }
 
+struct ObjectHelperRef {
+    int refCount;
+    ObjectHelper *obj;
+};
+
+// The "Abstract3DRenderer *" key identifies the renderer
+static QHash<const Abstract3DRenderer *, QHash<QString, ObjectHelperRef *> *> cacheTable;
+
 ObjectHelper::~ObjectHelper()
 {
 }
 
-void ObjectHelper::setObjectFile(const QString &objectFile)
+void ObjectHelper::resetObjectHelper(const Abstract3DRenderer *cacheId, ObjectHelper *&obj,
+                                     const QString &meshFile)
+{
+    Q_ASSERT(cacheId);
+
+    if (obj) {
+        const QString &oldFile = obj->objectFile();
+        if (meshFile == oldFile)
+            return; // same file, do nothing
+        releaseObjectHelper(cacheId, obj);
+    }
+    obj = getObjectHelper(cacheId, meshFile);
+}
+
+void ObjectHelper::releaseObjectHelper(const Abstract3DRenderer *cacheId, ObjectHelper *&obj)
+{
+    Q_ASSERT(cacheId);
+
+    if (obj) {
+        QHash<QString, ObjectHelperRef *> *objectTable = cacheTable.value(cacheId, 0);
+        if (objectTable) {
+            // Delete object if last reference is released
+            ObjectHelperRef *objRef = objectTable->value(obj->m_objectFile, 0);
+            if (objRef) {
+                objRef->refCount--;
+                if (objRef->refCount <= 0) {
+                    objectTable->remove(obj->m_objectFile);
+                    delete objRef->obj;
+                    delete objRef;
+                }
+            }
+            if (objectTable->isEmpty()) {
+                // Remove the entire cache if last object was removed
+                cacheTable.remove(cacheId);
+                delete objectTable;
+            }
+        } else {
+            // Just delete the object if unknown cache
+            delete obj;
+        }
+        obj = 0;
+    }
+}
+
+ObjectHelper *ObjectHelper::getObjectHelper(const Abstract3DRenderer *cacheId,
+                                            const QString &objectFile)
 {
-    m_objectFile = objectFile;
+    if (objectFile.isEmpty())
+        return 0;
+
+    QHash<QString, ObjectHelperRef *> *objectTable = cacheTable.value(cacheId, 0);
+    if (!objectTable) {
+        objectTable = new QHash<QString, ObjectHelperRef *>;
+        cacheTable.insert(cacheId, objectTable);
+    }
+
+    // Check if object helper for this mesh already exists
+    ObjectHelperRef *objRef = objectTable->value(objectFile, 0);
+    if (!objRef) {
+        objRef = new ObjectHelperRef;
+        objRef->refCount = 0;
+        objRef->obj = new ObjectHelper(objectFile);
+        objectTable->insert(objectFile, objRef);
+    }
+    objRef->refCount++;
+    return objRef->obj;
 }
 
 void ObjectHelper::load()
@@ -47,6 +118,10 @@ void ObjectHelper::load()
         glDeleteBuffers(1, &m_uvbuffer);
         glDeleteBuffers(1, &m_normalbuffer);
         glDeleteBuffers(1, &m_elementbuffer);
+        m_indices.clear();
+        m_indexedVertices.clear();
+        m_indexedUVs.clear();
+        m_indexedNormals.clear();
     }
     QVector<QVector3D> vertices;
     QVector<QVector2D> uvs;
@@ -56,36 +131,32 @@ void ObjectHelper::load()
         qFatal("loading failed");
 
     // Index vertices
-    QVector<unsigned short> indices;
-    QVector<QVector3D> indexed_vertices;
-    QVector<QVector2D> indexed_uvs;
-    QVector<QVector3D> indexed_normals;
-    VertexIndexer::indexVBO(vertices, uvs, normals, indices, indexed_vertices, indexed_uvs,
-                            indexed_normals);
+    VertexIndexer::indexVBO(vertices, uvs, normals, m_indices, m_indexedVertices, m_indexedUVs,
+                            m_indexedNormals);
 
-    m_indexCount = indices.size();
+    m_indexCount = m_indices.size();
 
     glGenBuffers(1, &m_vertexbuffer);
     glBindBuffer(GL_ARRAY_BUFFER, m_vertexbuffer);
-    glBufferData(GL_ARRAY_BUFFER, indexed_vertices.size() * sizeof(QVector3D),
-                 &indexed_vertices.at(0),
+    glBufferData(GL_ARRAY_BUFFER, m_indexedVertices.size() * sizeof(QVector3D),
+                 &m_indexedVertices.at(0),
                  GL_STATIC_DRAW);
 
     glGenBuffers(1, &m_normalbuffer);
     glBindBuffer(GL_ARRAY_BUFFER, m_normalbuffer);
-    glBufferData(GL_ARRAY_BUFFER, indexed_normals.size() * sizeof(QVector3D),
-                 &indexed_normals.at(0),
+    glBufferData(GL_ARRAY_BUFFER, m_indexedNormals.size() * sizeof(QVector3D),
+                 &m_indexedNormals.at(0),
                  GL_STATIC_DRAW);
 
     glGenBuffers(1, &m_uvbuffer);
     glBindBuffer(GL_ARRAY_BUFFER, m_uvbuffer);
-    glBufferData(GL_ARRAY_BUFFER, indexed_uvs.size() * sizeof(QVector2D),
-                 &indexed_uvs.at(0), GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, m_indexedUVs.size() * sizeof(QVector2D),
+                 &m_indexedUVs.at(0), GL_STATIC_DRAW);
 
     glGenBuffers(1, &m_elementbuffer);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementbuffer);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned short),
-                 &indices.at(0), GL_STATIC_DRAW);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indices.size() * sizeof(unsigned short),
+                 &m_indices.at(0), GL_STATIC_DRAW);
 
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);