git.cworth.org Git - apitrace/blob - gui/vertexdatainterpreter.cpp

   1 #include "vertexdatainterpreter.h"
   2
   3 #include <QListWidget>
   4 #include <QStringList>
   5
   6 #include <QDebug>
   7
   8 #include <GL/gl.h>
   9
  10 static int
  11 sizeForType(int glType)
  12 {
  13     switch(glType) {
  14     case GL_FLOAT:
  15         return sizeof(GLfloat);
  16     case GL_UNSIGNED_BYTE:
  17         return sizeof(GLubyte);
  18     case GL_BYTE:
  19         return sizeof(GLbyte);
  20     case GL_SHORT:
  21         return sizeof(GLshort);
  22     case GL_UNSIGNED_SHORT:
  23         return sizeof(GLushort);
  24     case GL_INT:
  25         return sizeof(GLint);
  26     case GL_UNSIGNED_INT:
  27         return sizeof(GLuint);
  28     default:
  29         return sizeof(GLint);
  30     }
  31 }
  32
  33 template <typename T>
  34 static QStringList
  35 convertData(const QByteArray &dataArray,
  36             int type,
  37             int stride,
  38             int numComponents)
  39 {
  40     QStringList strings;
  41
  42     const char *data = dataArray.constData();
  43     int typeSize = sizeForType(type);
  44     int sizePerAttribute = typeSize;
  45
  46     if (stride)
  47         sizePerAttribute = stride;
  48
  49     int numElements = dataArray.size() / sizePerAttribute;
  50
  51 #if 0
  52     qDebug() << "numElements = "<<numElements;
  53     qDebug() << "sizePerAttribute = "<<sizePerAttribute;
  54     qDebug() << "stride = "<<stride;
  55     qDebug() << "numComponents = "<<numComponents;
  56 #endif
  57
  58     if (numElements * sizePerAttribute > dataArray.size()) {
  59         qDebug()<<"Vertex data too large for the given binary data";
  60         return strings;
  61     }
  62     if ((numElements % numComponents) != 0) {
  63         qDebug()<<"Bad stride for the given vertex data";
  64         return strings;
  65     }
  66
  67     for (int i = 0; i < numElements; i += numComponents) {
  68         QString vectorString = QString::fromLatin1("%1) [").arg(i / numComponents);
  69         for (int j = 0; j < numComponents; ++j) {
  70             int idx = i + j;
  71             const T *elementPtr =
  72                 (const T*)(data + idx * sizePerAttribute);
  73             T elem = *elementPtr;
  74             vectorString += QString::number(elem);
  75             if ((j + 1) < numComponents)
  76                 vectorString += QLatin1String(", ");
  77         }
  78         vectorString += "]";
  79         strings += vectorString;
  80     }
  81
  82     return strings;
  83 }
  84
  85
  86 VertexDataInterpreter::VertexDataInterpreter(QObject *parent)
  87     : QObject(parent),
  88       m_listWidget(0),
  89       m_type(GL_FLOAT),
  90       m_stride(16),
  91       m_components(4)
  92 {
  93 }
  94
  95 void VertexDataInterpreter::setData(const QByteArray &data)
  96 {
  97     m_data = data;
  98     if (m_listWidget)
  99         m_listWidget->clear();
 100 }
 101
 102 QByteArray VertexDataInterpreter::data() const
 103 {
 104     return m_data;
 105 }
 106
 107 void VertexDataInterpreter::setType(int type)
 108 {
 109     m_type = type;
 110 }
 111
 112 int VertexDataInterpreter::type() const
 113 {
 114     return m_type;
 115 }
 116
 117 void VertexDataInterpreter::setStride(int stride)
 118 {
 119     m_stride = stride;
 120 }
 121
 122 int VertexDataInterpreter::stride() const
 123 {
 124     return m_stride;
 125 }
 126
 127 void VertexDataInterpreter::setComponents(int num)
 128 {
 129     m_components = num;
 130 }
 131
 132 int VertexDataInterpreter::components() const
 133 {
 134     return m_components;
 135 }
 136
 137 void VertexDataInterpreter::setListWidget(QListWidget *listWidget)
 138 {
 139     m_listWidget = listWidget;
 140 }
 141
 142 void VertexDataInterpreter::interpretData()
 143 {
 144     if (!m_listWidget)
 145         return;
 146
 147     m_listWidget->clear();
 148
 149     if (m_data.isEmpty() || !m_components)
 150         return;
 151
 152     QStringList lst;
 153     switch(m_type) {
 154     case GL_FLOAT:
 155         lst = convertData<float>(m_data, m_type, m_stride, m_components);
 156         break;
 157     case GL_UNSIGNED_BYTE:
 158         lst = convertData<quint8>(m_data, m_type, m_stride, m_components);
 159         break;
 160     case GL_BYTE:
 161         lst = convertData<qint8>(m_data, m_type, m_stride, m_components);
 162         break;
 163     case GL_SHORT:
 164         lst = convertData<qint16>(m_data, m_type, m_stride, m_components);
 165         break;
 166     case GL_UNSIGNED_SHORT:
 167         lst = convertData<quint16>(m_data, m_type, m_stride, m_components);
 168         break;
 169     case GL_INT:
 170         lst = convertData<unsigned int>(m_data, m_type, m_stride, m_components);
 171         break;
 172     case GL_UNSIGNED_INT:
 173         lst = convertData<int>(m_data, m_type, m_stride, m_components);
 174         break;
 175     default:
 176         qDebug()<<"unkown gltype = "<<m_type;
 177     }
 178     //qDebug()<<"list is "<<lst;
 179     m_listWidget->addItems(lst);
 180 }
 181
 182
 183 void VertexDataInterpreter::setTypeFromString(const QString &str)
 184 {
 185     if (str == QLatin1String("GL_FLOAT")) {
 186         setType(GL_FLOAT);
 187     } else if (str == QLatin1String("GL_INT")) {
 188         setType(GL_INT);
 189     } else if (str == QLatin1String("GL_UNSIGNED_INT")) {
 190         setType(GL_UNSIGNED_INT);
 191     } else if (str == QLatin1String("GL_SHORT")) {
 192         setType(GL_SHORT);
 193     } else if (str == QLatin1String("GL_UNSIGNED_SHORT")) {
 194         setType(GL_UNSIGNED_SHORT);
 195     } else if (str == QLatin1String("GL_BYTE")) {
 196         setType(GL_BYTE);
 197     } else if (str == QLatin1String("GL_UNSIGNED_BYTE")) {
 198         setType(GL_UNSIGNED_BYTE);
 199     } else {
 200         qDebug()<<"unknown vertex data type";
 201     }
 202 }
 203
 204 #include "vertexdatainterpreter.moc"