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