QAbstractAttribute: Type abstracted with an enum

Also added a dataSize property to know the number of components per vertice (1 - 4)

Change-Id: Iaa7cee2a53958ed2ec2f603f3ffc7971c027991d
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

4 files changed, 99 insertions, 99 deletions

diff --git a/src/render/io/gltfparser.cpp b/src/render/io/gltfparser.cpp
index 1baaf1712..65c800fb0 100644
--- a/src/render/io/gltfparser.cpp
+++ b/src/render/io/gltfparser.cpp
@@ -199,6 +199,59 @@ const QString KEY_INTERNAL_FORMAT = QStringLiteral("internalFormat");
 //    return QParameter::Undefined;
 //}
 
+QAbstractAttribute::DataType typeFromGLType(GLint dataType, uint &dataCount)
+{
+    switch (dataType) {
+
+    case GL_UNSIGNED_SHORT:
+        dataCount = 1;
+        return QAbstractAttribute::UnsignedShort;
+
+    case GL_UNSIGNED_BYTE:
+        dataCount = 1;
+        return QAbstractAttribute::UnsignedByte;
+
+    case GL_UNSIGNED_INT:
+        dataCount = 1;
+        return QAbstractAttribute::UnsignedInt;
+
+    case GL_SHORT:
+        dataCount = 1;
+        return QAbstractAttribute::Short;
+
+    case GL_BYTE:
+        dataCount = 1;
+        return QAbstractAttribute::Byte;
+
+    case GL_INT:
+        dataCount = 1;
+        return QAbstractAttribute::Int;
+
+    case GL_FLOAT:
+        dataCount = 1;
+        break;
+
+    case GL_FLOAT_VEC2:
+        dataCount = 2;
+        break;
+
+    case GL_FLOAT_VEC3:
+        dataCount = 3;
+        break;
+
+    case GL_FLOAT_VEC4:
+        dataCount = 4;
+        break;
+
+// TO DO: Handle doubles
+
+    default:
+        Q_UNREACHABLE();
+    }
+
+    return QAbstractAttribute::Float;
+}
+
 } // of anonymous namespace
 
 class GLTFParserMeshPrivate;
@@ -677,7 +730,10 @@ void GLTFParser::processJSONAccessor( QString id, const QJsonObject& json )
     if ( json.contains(KEY_BYTE_STRIDE))
         stride = json.value(KEY_BYTE_STRIDE).toInt();
 
-    QAttribute *attr( new QAttribute( buf, type, count, offset, stride ) );
+    uint dataSize = 0;
+    QAttribute::DataType dataType = typeFromGLType(type, dataSize);
+
+    QAttribute *attr( new QAttribute( buf, dataType, dataSize, count, offset, stride ) );
     m_attributeDict[id] = attr;
 }
 
diff --git a/src/render/io/objloader.cpp b/src/render/io/objloader.cpp
index 7cd0dce69..e727f3210 100644
--- a/src/render/io/objloader.cpp
+++ b/src/render/io/objloader.cpp
@@ -249,36 +249,36 @@ QMeshData *ObjLoader::mesh() const
     buf->setData(bufferBytes);
 
 
-    mesh->addAttribute(QMeshData::defaultPositionAttributeName(), new QAttribute(buf, GL_FLOAT_VEC3, count, 0, stride));
+    mesh->addAttribute(QMeshData::defaultPositionAttributeName(), new QAttribute(buf, QAttribute::Float, 3, count, 0, stride));
     quint32 offset = sizeof(float) * 3;
 
     if (hasTextureCoordinates()) {
-        mesh->addAttribute(QMeshData::defaultTextureCoordinateAttributeName(), new QAttribute(buf, GL_FLOAT_VEC2, count, offset, stride));
+        mesh->addAttribute(QMeshData::defaultTextureCoordinateAttributeName(), new QAttribute(buf, QAttribute::Float, 2, count, offset, stride));
         offset += sizeof(float) * 2;
     }
 
     if (hasNormals()) {
-        mesh->addAttribute(QMeshData::defaultNormalAttributeName(), new QAttribute(buf, GL_FLOAT_VEC3, count, offset, stride));
+        mesh->addAttribute(QMeshData::defaultNormalAttributeName(), new QAttribute(buf, QAttribute::Float, 3, count, offset, stride));
         offset += sizeof(float) * 3;
     }
 
     if (hasTangents()) {
-        mesh->addAttribute(QMeshData::defaultTangentAttributeName(), new QAttribute(buf, GL_FLOAT_VEC4, count, offset, stride));
+        mesh->addAttribute(QMeshData::defaultTangentAttributeName(), new QAttribute(buf, QAttribute::Float, 4, count, offset, stride));
         offset += sizeof(float) * 4;
     }
 
     QByteArray indexBytes;
-    GLuint ty;
+    QAttribute::DataType ty;
     if (m_indices.size() < 65536) {
         // we can use USHORT
-        ty = GL_UNSIGNED_SHORT;
+        ty = QAttribute::UnsignedShort;
         indexBytes.resize(m_indices.size() * sizeof(quint16));
         quint16* usptr = reinterpret_cast<quint16*>(indexBytes.data());
         for (int i=0; i<m_indices.size(); ++i)
             *usptr++ = static_cast<quint16>(m_indices.at(i));
     } else {
         // use UINT - no conversion needed, but let's ensure int is 32-bit!
-        ty = GL_UNSIGNED_INT;
+        ty = QAttribute::UnsignedInt;
         Q_ASSERT(sizeof(int) == sizeof(quint32));
         indexBytes.resize(m_indices.size() * sizeof(quint32));
         memcpy(indexBytes.data(), reinterpret_cast<const char*>(m_indices.data()), indexBytes.size());
@@ -287,7 +287,7 @@ QMeshData *ObjLoader::mesh() const
     QBuffer *indexBuffer(new QBuffer(QBuffer::IndexBuffer));
     indexBuffer->setUsage(QBuffer::StaticDraw);
     indexBuffer->setData(indexBytes);
-    mesh->setIndexAttribute(new QAttribute(indexBuffer, ty, m_indices.size(), 0, 0));
+    mesh->setIndexAttribute(new QAttribute(indexBuffer, ty, 1, m_indices.size(), 0, 0));
 
     mesh->computeBoundsFromAttribute(QMeshData::defaultPositionAttributeName());
     qCDebug(Render::Io) << "computed bounds is:" << mesh->boundingBox();
diff --git a/src/render/io/qattribute.cpp b/src/render/io/qattribute.cpp
index 07612ef71..80fa9dd49 100644
--- a/src/render/io/qattribute.cpp
+++ b/src/render/io/qattribute.cpp
@@ -61,13 +61,13 @@ QAttribute::QAttribute(QNode *parent)
 {
 }
 
-QAttribute::QAttribute(QBuffer *buf, int type, int count, int offset, int stride)
-    : QAbstractAttribute(*new QAttributePrivate(), buf, QString(), type, count, offset, stride)
+QAttribute::QAttribute(QBuffer *buf, DataType type, uint dataSize, int count, int offset, int stride)
+    : QAbstractAttribute(*new QAttributePrivate(), buf, QString(), type, dataSize, count, offset, stride)
 {
 }
 
-QAttribute::QAttribute(QBuffer *buf, const QString &name, int type, int count, int offset, int stride)
-    : QAbstractAttribute(*new QAttributePrivate(), buf, name, type, count, offset, stride)
+QAttribute::QAttribute(QBuffer *buf, const QString &name, DataType type, uint dataSize, int count, int offset, int stride)
+    : QAbstractAttribute(*new QAttributePrivate(), buf, name, type, dataSize, count, offset, stride)
 {
 }
 
@@ -90,18 +90,13 @@ QVector<QVector4D> QAttribute::asVector4D() const
     const float* fptr;
     int stride;
 
-    switch (type()) {
-    case GL_FLOAT_VEC2:
-        stride = sizeof(float) * 2; break;
-
-    case GL_FLOAT_VEC3:
-        stride = sizeof(float) * 3; break;
-
-    case GL_FLOAT_VEC4:
-        stride = sizeof(float) * 4; break;
+    switch (dataType()) {
+    case QAttribute::Float:
+        stride = sizeof(float) * dataSize();
+        break;
 
     default:
-        qCDebug(Render::Io) << Q_FUNC_INFO << "can't convert" << QString::number(type(), 16) << "to QVector3D";
+        qCDebug(Render::Io) << Q_FUNC_INFO << "can't convert" << dataType() << "x" << dataSize() << "to QVector3D";
         return QVector<QVector4D>();
     }
 
@@ -114,28 +109,8 @@ QVector<QVector4D> QAttribute::asVector4D() const
         QVector4D v;
         fptr = reinterpret_cast<const float*>(rawBuffer);
 
-        switch (type()) {
-        case GL_FLOAT_VEC2:
-            v.setX(fptr[0]);
-            v.setY(fptr[1]);
-            break;
-
-        case GL_FLOAT_VEC3:
-            v.setX(fptr[0]);
-            v.setY(fptr[1]);
-            v.setZ(fptr[2]);
-            break;
-
-        case GL_FLOAT_VEC4:
-            v.setX(fptr[0]);
-            v.setY(fptr[1]);
-            v.setZ(fptr[2]);
-            v.setW(fptr[3]);
-            break;
-
-        default:
-            break; // should never happen, we check types above
-        }
+        for (uint i = 0, m = dataSize(); i < m; ++i)
+            v[i] = fptr[i];
 
         result[c] = v;
         rawBuffer += stride;
@@ -153,18 +128,13 @@ QVector<QVector3D> QAttribute::asVector3D() const
     const float* fptr;
     int stride;
 
-    switch (type()) {
-    case GL_FLOAT_VEC2:
-        stride = sizeof(float) * 2; break;
-
-    case GL_FLOAT_VEC3:
-        stride = sizeof(float) * 3; break;
-
-    case GL_FLOAT_VEC4:
-        stride = sizeof(float) * 4; break;
+    switch (dataType()) {
+    case QAttribute::Float:
+        stride = sizeof(float) * dataSize();
+        break;
 
     default:
-        qCDebug(Render::Io) << Q_FUNC_INFO << "can't convert" << QString::number(type(), 16) << "to QVector3D";
+        qCDebug(Render::Io) << Q_FUNC_INFO << "can't convert" << dataType() << "x" << dataSize() << "to QVector3D";
         return QVector<QVector3D>();
     }
 
@@ -177,22 +147,8 @@ QVector<QVector3D> QAttribute::asVector3D() const
         QVector3D v;
         fptr = reinterpret_cast<const float*>(rawBuffer);
 
-        switch (type()) {
-        case GL_FLOAT_VEC2:
-            v.setX(fptr[0]);
-            v.setY(fptr[1]);
-            break;
-
-        case GL_FLOAT_VEC3:
-        case GL_FLOAT_VEC4:
-            v.setX(fptr[0]);
-            v.setY(fptr[1]);
-            v.setZ(fptr[2]);
-            break;
-
-        default:
-            break; // should never happen, we check types above
-        }
+        for (uint i = 0, m = qMin(dataSize(), 3U); i < m; ++i)
+            v[i] = fptr[i];
 
         result[c] = v;
         rawBuffer += stride;
@@ -209,18 +165,13 @@ QVector<QVector2D> QAttribute::asVector2D() const
     float* fptr;
     int stride;
 
-    switch (type()) {
-    case GL_FLOAT_VEC2:
-        stride = sizeof(float) * 2; break;
-
-    case GL_FLOAT_VEC3:
-        stride = sizeof(float) * 3; break;
-
-    case GL_FLOAT_VEC4:
-        stride = sizeof(float) * 4; break;
+    switch (dataType()) {
+    case QAttribute::Float:
+        stride = sizeof(float) * dataSize();
+        break;
 
     default:
-        qCDebug(Render::Io) << Q_FUNC_INFO << "can't convert" << QString::number(type(), 16) << "to QVector2D";
+        qCDebug(Render::Io) << Q_FUNC_INFO << "can't convert" << dataType() << "x" << dataSize() << "to QVector3D";
         return QVector<QVector2D>();
     }
 
@@ -233,8 +184,8 @@ QVector<QVector2D> QAttribute::asVector2D() const
     for (uint c = 0; c < d->m_count; ++c) {
         QVector2D v;
         fptr = reinterpret_cast<float*>(rawBuffer);
-        v.setX(fptr[0]);
-        v.setY(fptr[1]);
+        for (uint i = 0, m = qMin(dataSize(), 2U); i < m; ++i)
+            v[i] = fptr[i];
         result[c] = v;
         rawBuffer += stride;
     }
@@ -254,33 +205,26 @@ void QAttribute::dump(int count)
     int stride = d->m_byteStride;
 
     for (int c=0; c<count; ++c) {
-        switch (type()) {
-        case GL_UNSIGNED_SHORT:
+        switch (dataType()) {
+        case QAttribute::UnsignedShort:
             if (stride == 0)
                 stride = sizeof(quint16);
             usptr = reinterpret_cast<const quint16*>(rawBuffer + stride * c);
             qCDebug(Render::Io) << c << ":u16:" << usptr[0];
             break;
-        case GL_UNSIGNED_INT:
+        case QAttribute::UnsignedInt:
             if (stride == 0)
                 stride = sizeof(quint32);
             qCDebug(Render::Io) << c << ":u32:" << reinterpret_cast<const quint32*>(rawBuffer + stride * c)[0];
             break;
-        case GL_FLOAT_VEC2:
-            if (stride == 0)
-                stride = sizeof(float) * 2;
-            fptr = reinterpret_cast<const float*>(rawBuffer + stride * c);
-            qCDebug(Render::Io) << c << ":vec2:"<< fptr[0] << fptr[1];
-            break;
-
-        case GL_FLOAT_VEC3:
+        case QAttribute::Float:
             if (stride == 0)
-                stride = sizeof(float) * 3;
+                stride = sizeof(float) * dataSize();
             fptr = reinterpret_cast<const float*>(rawBuffer + stride * c);
-            qCDebug(Render::Io) << c << ":vec3:" << fptr[0] << fptr[1] << fptr[2];
+            qCDebug(Render::Io) << c << QString::fromLatin1(":vec") + QString::number(dataSize()) << fptr[0] << fptr[1];
             break;
 
-        default: qCDebug(Render::Io) << Q_FUNC_INFO << "unspported type:" << QString::number(type(), 16);
+        default: qCDebug(Render::Io) << Q_FUNC_INFO << "unspported type:" << dataType();
         }
     }
 }
diff --git a/src/render/io/qattribute.h b/src/render/io/qattribute.h
index 39948101c..ec281973f 100644
--- a/src/render/io/qattribute.h
+++ b/src/render/io/qattribute.h
@@ -54,8 +54,8 @@ class QT3DRENDERERSHARED_EXPORT QAttribute : public QAbstractAttribute
 
 public:
     explicit QAttribute(QNode *parent = 0);
-    QAttribute(QBuffer *buf, int type, int count, int offset=0, int stride = 0);
-    QAttribute(QBuffer *buf, const QString &name, int type, int count, int offset=0, int stride = 0);
+    QAttribute(QBuffer *buf, DataType type, uint dataSize, int count, int offset=0, int stride = 0);
+    QAttribute(QBuffer *buf, const QString &name, DataType type, uint dataSize, int count, int offset=0, int stride = 0);
     ~QAttribute();
 
     QVector<QVector4D> asVector4D() const Q_DECL_OVERRIDE;