X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=gui%2Fvertexdatainterpreter.cpp;h=a3012310e1349e7b4cf87bdad79671e281cbfecc;hb=c8695f74ce1ee6a93dee4b3f7da5a70a64706c82;hp=e00466b18bea56ab15c2ac764328a3f76fad402c;hpb=8e7a4ff9d168734533fa1f725b013c048e49b3e9;p=apitrace

diff --git a/gui/vertexdatainterpreter.cpp b/gui/vertexdatainterpreter.cpp
index e00466b..a301231 100644
--- a/gui/vertexdatainterpreter.cpp
+++ b/gui/vertexdatainterpreter.cpp
@@ -5,28 +5,27 @@
 
 #include <QDebug>
 
-#include <GL/gl.h>
+#include <qmath.h>
 
 static int
-sizeForType(int glType)
-{
-    switch(glType) {
-    case GL_FLOAT:
-        return sizeof(GLfloat);
-    case GL_UNSIGNED_BYTE:
-        return sizeof(GLubyte);
-    case GL_BYTE:
-        return sizeof(GLbyte);
-    case GL_SHORT:
-        return sizeof(GLshort);
-    case GL_UNSIGNED_SHORT:
-        return sizeof(GLushort);
-    case GL_INT:
-        return sizeof(GLint);
-    case GL_UNSIGNED_INT:
-        return sizeof(GLuint);
+sizeForType(int type)
+{
+    switch(type) {
+    case DT_INT8:
+    case DT_UINT8:
+        return 1;
+    case DT_INT16:
+    case DT_UINT16:
+        return 2;
+    case DT_INT32:
+    case DT_UINT32:
+        return 4;
+    case DT_FLOAT:
+        return sizeof(float);
+    case DT_DOUBLE:
+        return sizeof(double);
     default:
-        return sizeof(GLint);
+        return sizeof(int);
     }
 }
 
@@ -35,41 +34,47 @@ static QStringList
 convertData(const QByteArray &dataArray,
             int type,
             int stride,
-            int numComponents)
+            int numComponents,
+            int startingOffset)
 {
     QStringList strings;
 
-    const char *data = dataArray.constData();
+    int dataSize = dataArray.size() - startingOffset;
+    const char *data = dataArray.constData() + startingOffset;
     int typeSize = sizeForType(type);
-    int sizePerAttribute = typeSize;
+    int elementSize = numComponents * typeSize;
+
+    if (!stride)
+        stride = elementSize;
 
-    if (stride)
-        sizePerAttribute = stride;
+    int numElements = dataSize / stride;
 
-    int numElements = dataArray.size() / sizePerAttribute;
+    if ((numElements % numComponents) != 0) {
+        int temp = qFloor(dataSize / (float)stride);
+        int fullElemSize = temp * stride;
+        if (fullElemSize + numComponents * typeSize <= dataSize) {
+            /* num full elements plus the part of the buffer in which we fit */
+            numElements = temp + 1;
+        } else {
+            numElements = temp;
+        }
+    }
 
 #if 0
     qDebug() << "numElements = "<<numElements;
-    qDebug() << "sizePerAttribute = "<<sizePerAttribute;
+    qDebug() << "elementSize = "<<elementSize;
     qDebug() << "stride = "<<stride;
     qDebug() << "numComponents = "<<numComponents;
+    qDebug() << "typeSize = "<<typeSize;
 #endif
 
-    if (numElements * sizePerAttribute > dataArray.size()) {
-        qDebug()<<"Vertex data too large for the given binary data";
-        return strings;
-    }
-    if ((numElements % numComponents) != 0) {
-        qDebug()<<"Bad stride for the given vertex data";
-        return strings;
-    }
 
-    for (int i = 0; i < numElements; i += numComponents) {
-        QString vectorString = QString::fromLatin1("%1) [").arg(i / numComponents);
+    for (int i = 0; i < numElements; ++i) {
+        QString vectorString = QString::fromLatin1("%1) [").arg(i);
         for (int j = 0; j < numComponents; ++j) {
-            int idx = i + j;
+            int offset = i*stride + j*typeSize;
             const T *elementPtr =
-                (const T*)(data + idx * sizePerAttribute);
+                (const T*)(data + offset);
             T elem = *elementPtr;
             vectorString += QString::number(elem);
             if ((j + 1) < numComponents)
@@ -86,9 +91,10 @@ convertData(const QByteArray &dataArray,
 VertexDataInterpreter::VertexDataInterpreter(QObject *parent)
     : QObject(parent),
       m_listWidget(0),
-      m_type(GL_FLOAT),
+      m_type(DT_FLOAT),
       m_stride(16),
-      m_components(4)
+      m_components(4),
+      m_startingOffset(0)
 {
 }
 
@@ -151,26 +157,37 @@ void VertexDataInterpreter::interpretData()
 
     QStringList lst;
     switch(m_type) {
-    case GL_FLOAT:
-        lst = convertData<float>(m_data, m_type, m_stride, m_components);
+    case DT_INT8:
+        lst = convertData<qint8>(m_data, m_type, m_stride, m_components,
+                                 m_startingOffset);
         break;
-    case GL_UNSIGNED_BYTE:
-        lst = convertData<quint8>(m_data, m_type, m_stride, m_components);
+    case DT_UINT8:
+        lst = convertData<quint8>(m_data, m_type, m_stride, m_components,
+                                  m_startingOffset);
         break;
-    case GL_BYTE:
-        lst = convertData<qint8>(m_data, m_type, m_stride, m_components);
+    case DT_INT16:
+        lst = convertData<qint16>(m_data, m_type, m_stride, m_components,
+                                  m_startingOffset);
         break;
-    case GL_SHORT:
-        lst = convertData<qint16>(m_data, m_type, m_stride, m_components);
+    case DT_UINT16:
+        lst = convertData<quint16>(m_data, m_type, m_stride, m_components,
+                                   m_startingOffset);
         break;
-    case GL_UNSIGNED_SHORT:
-        lst = convertData<quint16>(m_data, m_type, m_stride, m_components);
+    case DT_INT32:
+        lst = convertData<qint32>(m_data, m_type, m_stride, m_components,
+                                  m_startingOffset);
         break;
-    case GL_INT:
-        lst = convertData<unsigned int>(m_data, m_type, m_stride, m_components);
+    case DT_UINT32:
+        lst = convertData<quint32>(m_data, m_type, m_stride, m_components,
+                                   m_startingOffset);
         break;
-    case GL_UNSIGNED_INT:
-        lst = convertData<int>(m_data, m_type, m_stride, m_components);
+    case DT_FLOAT:
+        lst = convertData<float>(m_data, m_type, m_stride, m_components,
+                                 m_startingOffset);
+        break;
+    case DT_DOUBLE:
+        lst = convertData<double>(m_data, m_type, m_stride, m_components,
+                                  m_startingOffset);
         break;
     default:
         qDebug()<<"unkown gltype = "<<m_type;
@@ -183,22 +200,34 @@ void VertexDataInterpreter::interpretData()
 void VertexDataInterpreter::setTypeFromString(const QString &str)
 {
     if (str == QLatin1String("GL_FLOAT")) {
-        setType(GL_FLOAT);
+        setType(DT_FLOAT);
     } else if (str == QLatin1String("GL_INT")) {
-        setType(GL_INT);
+        setType(DT_INT32);
     } else if (str == QLatin1String("GL_UNSIGNED_INT")) {
-        setType(GL_UNSIGNED_INT);
+        setType(DT_UINT32);
     } else if (str == QLatin1String("GL_SHORT")) {
-        setType(GL_SHORT);
+        setType(DT_INT16);
     } else if (str == QLatin1String("GL_UNSIGNED_SHORT")) {
-        setType(GL_UNSIGNED_SHORT);
+        setType(DT_UINT16);
     } else if (str == QLatin1String("GL_BYTE")) {
-        setType(GL_BYTE);
+        setType(DT_INT8);
     } else if (str == QLatin1String("GL_UNSIGNED_BYTE")) {
-        setType(GL_UNSIGNED_BYTE);
+        setType(DT_UINT8);
+    } else if (str == QLatin1String("GL_DOUBLE")) {
+        setType(DT_DOUBLE);
     } else {
         qDebug()<<"unknown vertex data type";
     }
 }
 
+int VertexDataInterpreter::startingOffset() const
+{
+    return m_startingOffset;
+}
+
+void VertexDataInterpreter::setStartingOffset(int offset)
+{
+    m_startingOffset = offset;
+}
+
 #include "vertexdatainterpreter.moc"