Accept zero valued bitmasks.

[apitrace] / gui / apitracecall.cpp

diff --git a/gui/apitracecall.cpp b/gui/apitracecall.cpp
index 8c6359cd74fdc062dde5238f69d648312566ff4f..2d28e164cc550d667fed83f645a1473932beb84b 100644 (file)
--- a/gui/apitracecall.cpp
+++ b/gui/apitracecall.cpp
@@ -284,9 +284,19 @@ QString ApiTraceCall::toHtml() const
     if (!m_richText.isEmpty())
         return m_richText;
 
-    m_richText = QString::fromLatin1("%1) <span style=\"font-weight:bold\">%2</span>(")
-                 .arg(index)
-                 .arg(name);
+    if (helpUrl.isEmpty()) {
+        m_richText = QString::fromLatin1(
+            "%1) <span style=\"font-weight:bold\">%2</span>(")
+                     .arg(index)
+                     .arg(name);
+    } else {
+        m_richText = QString::fromLatin1(
+            "%1) <span style=\"font-weight:bold\"><a href=\"%2\">%3</a></span>(")
+                      .arg(index)
+                      .arg(helpUrl.toString())
+                      .arg(name);
+    }
+
     for (int i = 0; i < argNames.count(); ++i) {
         m_richText += argNames[i];
         m_richText += QString::fromLatin1(" = ");
@@ -313,6 +323,7 @@ QString ApiTraceCall::filterText() const
         return m_filterText;
 
     m_filterText = name;
+    m_filterText += QLatin1String("(");
     for (int i = 0; i < argNames.count(); ++i) {
         m_filterText += argNames[i];
         m_filterText += QString::fromLatin1(" = ");
@@ -387,12 +398,17 @@ ApiTraceCall::~ApiTraceCall()
 {
 }
 
-QVariantMap ApiTraceEvent::state() const
+QVariantMap ApiTraceEvent::stateParameters() const
+{
+    return m_state.parameters();
+}
+
+ApiTraceState ApiTraceEvent::state() const
 {
     return m_state;
 }
 
-void ApiTraceEvent::setState(const QVariantMap &state)
+void ApiTraceEvent::setState(const ApiTraceState &state)
 {
     m_state = state;
 }
@@ -406,3 +422,114 @@ int ApiTraceCall::binaryDataIndex() const
 {
     return m_binaryDataIndex;
 }
+
+ApiTraceState::ApiTraceState()
+{
+}
+
+ApiTraceState::ApiTraceState(const QVariantMap &parsedJson)
+{
+    m_parameters = parsedJson[QLatin1String("parameters")].toMap();
+    QVariantMap attachedShaders =
+        parsedJson[QLatin1String("shaders")].toMap();
+    QVariantMap::const_iterator itr;
+
+
+    for (itr = attachedShaders.constBegin(); itr != attachedShaders.constEnd(); ++itr) {
+        QString type = itr.key();
+        QString source = itr.value().toString();
+        m_shaderSources[type] = source;
+    }
+
+    QVariantList textureUnits =
+        parsedJson[QLatin1String("textures")].toList();
+    for (int i = 0; i < textureUnits.count(); ++i) {
+        QVariantMap unit = textureUnits[i].toMap();
+        for (itr = unit.constBegin(); itr != unit.constEnd(); ++itr) {
+            QVariantMap target = itr.value().toMap();
+            if (target.count()) {
+                QVariantList levels = target[QLatin1String("levels")].toList();
+                for (int j = 0; j < levels.count(); ++j) {
+                    QVariantMap level = levels[j].toMap();
+                    QVariantMap image = level[QLatin1String("image")].toMap();
+                    QSize size(image[QLatin1String("__width__")].toInt(),
+                               image[QLatin1String("__height__")].toInt());
+                    QString cls = image[QLatin1String("__class__")].toString();
+                    QString type = image[QLatin1String("__type__")].toString();
+                    bool normalized =
+                        image[QLatin1String("__normalized__")].toBool();
+                    int numChannels =
+                        image[QLatin1String("__channels__")].toInt();
+
+                    Q_ASSERT(type == QLatin1String("uint8"));
+                    Q_ASSERT(normalized == true);
+
+                    QByteArray dataArray =
+                        image[QLatin1String("__data__")].toByteArray();
+
+                    ApiTexture tex;
+                    tex.setSize(size);
+                    tex.setNumChannels(numChannels);
+                    tex.setLevel(j);
+                    tex.setUnit(i);
+                    tex.setTarget(itr.key());
+                    tex.contentsFromBase64(dataArray);
+
+                    m_textures.append(tex);
+                }
+            }
+        }
+    }
+
+    QVariantMap fbos =
+        parsedJson[QLatin1String("framebuffer")].toMap();
+    for (itr = fbos.constBegin(); itr != fbos.constEnd(); ++itr) {
+        QVariantMap buffer = itr.value().toMap();
+        QSize size(buffer[QLatin1String("__width__")].toInt(),
+                   buffer[QLatin1String("__height__")].toInt());
+        QString cls = buffer[QLatin1String("__class__")].toString();
+        QString type = buffer[QLatin1String("__type__")].toString();
+        bool normalized = buffer[QLatin1String("__normalized__")].toBool();
+        int numChannels = buffer[QLatin1String("__channels__")].toInt();
+
+        Q_ASSERT(type == QLatin1String("uint8"));
+        Q_ASSERT(normalized == true);
+
+        QByteArray dataArray =
+            buffer[QLatin1String("__data__")].toByteArray();
+
+        ApiFramebuffer fbo;
+        fbo.setSize(size);
+        fbo.setNumChannels(numChannels);
+        fbo.setType(itr.key());
+        fbo.contentsFromBase64(dataArray);
+        m_framebuffers.append(fbo);
+    }
+}
+
+QVariantMap ApiTraceState::parameters() const
+{
+    return m_parameters;
+}
+
+QMap<QString, QString> ApiTraceState::shaderSources() const
+{
+    return m_shaderSources;
+}
+
+bool ApiTraceState::isEmpty() const
+{
+    return m_parameters.isEmpty();
+}
+
+QList<ApiTexture> ApiTraceState::textures() const
+{
+    return m_textures;
+}
+
+QList<ApiFramebuffer> ApiTraceState::framebuffers() const
+{
+    return m_framebuffers;
+}
+
+