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