]> git.cworth.org Git - apitrace/blob - gui/vertexdatainterpreter.cpp
trim: Fix short command-line option -a for "apitrace trim"
[apitrace] / 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"