Read the surface data from json.

[apitrace] / gui / apitracecall.cpp

diff --git a/gui/apitracecall.cpp b/gui/apitracecall.cpp
index b772b66846dff89c6790d1d9ab9915da75f62310..70cc3f79cc64cb95855c83137ecd31257c238f7b 100644 (file)
--- a/gui/apitracecall.cpp
+++ b/gui/apitracecall.cpp
@@ -3,6 +3,7 @@
 #include "trace_model.hpp"
 
 #include <QDebug>
+#include <QObject>
 
 ApiPointer::ApiPointer(int val)
     : m_value(val)
@@ -22,6 +23,15 @@ QString apiVariantToString(const QVariant &variant)
     if (variant.userType() == QVariant::Double) {
         return QString::number(variant.toFloat());
     }
+    if (variant.userType() == QVariant::ByteArray) {
+        if (variant.toByteArray().size() < 1024) {
+            int bytes = variant.toByteArray().size();
+            return QObject::tr("[binary data, size = %1 bytes]").arg(bytes);
+        } else {
+            float kb = variant.toByteArray().size()/1024.;
+            return QObject::tr("[binary data, size = %1 kb]").arg(kb);
+        }
+    }
 
     if (variant.userType() < QVariant::UserType) {
         return variant.toString();
@@ -233,12 +243,32 @@ QStaticText ApiTraceCall::staticText() const
     QString richText = QString::fromLatin1("<span style=\"font-weight:bold\">%1</span>(").arg(name);
     for (int i = 0; i < argNames.count(); ++i) {
         richText += QLatin1String("<span style=\"color:#0000ff\">");
-        richText += apiVariantToString(argValues[i]);
+        QString argText = apiVariantToString(argValues[i]);
+
+        //if arguments are really long (e.g. shader text), cut them
+        // and elide it
+        if (argText.length() > 40) {
+            QString shortened = argText.mid(0, 40);
+            shortened[argText.length() - 5] = '.';
+            shortened[argText.length() - 4] = '.';
+            shortened[argText.length() - 3] = '.';
+            shortened[argText.length() - 2] = argText[argText.length() - 2];
+            shortened[argText.length() - 1] = argText[argText.length() - 1];
+            richText += shortened;
+        } else {
+            richText += argText;
+        }
         richText += QLatin1String("</span>");
         if (i < argNames.count() - 1)
             richText += QString::fromLatin1(", ");
     }
     richText += QLatin1String(")");
+    if (returnValue.isValid()) {
+        richText += QLatin1String(" = ");
+        richText += QLatin1String("<span style=\"color:#0000ff\">");
+        richText += apiVariantToString(returnValue);
+        richText += QLatin1String("</span>");
+    }
 
     m_staticText.setText(richText);
     QTextOption opt;
@@ -254,7 +284,19 @@ QString ApiTraceCall::toHtml() const
     if (!m_richText.isEmpty())
         return m_richText;
 
-    m_richText = QString::fromLatin1("<span style=\"font-weight:bold\">%1</span>(").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(" = ");
@@ -284,6 +326,11 @@ QString ApiTraceCall::filterText() const
     for (int i = 0; i < argNames.count(); ++i) {
         m_filterText += argNames[i];
         m_filterText += QString::fromLatin1(" = ");
+
+        if (argValues[i].type() == QVariant::ByteArray) {
+            m_hasBinaryData = true;
+            m_binaryDataIndex = i;
+        }
         m_filterText += apiVariantToString(argValues[i]);
         if (i < argNames.count() - 1)
             m_filterText += QString::fromLatin1(", ");
@@ -330,7 +377,9 @@ ApiTraceFrame::ApiTraceFrame()
 }
 
 ApiTraceCall::ApiTraceCall()
-    : ApiTraceEvent(ApiTraceEvent::Call)
+    : ApiTraceEvent(ApiTraceEvent::Call),
+      m_hasBinaryData(false),
+      m_binaryDataIndex(0)
 {
 }
 
@@ -347,3 +396,111 @@ ApiTraceEvent::ApiTraceEvent(Type t)
 ApiTraceCall::~ApiTraceCall()
 {
 }
+
+QVariantMap ApiTraceEvent::stateParameters() const
+{
+    return m_state.parameters();
+}
+
+ApiTraceState ApiTraceEvent::state() const
+{
+    return m_state;
+}
+
+void ApiTraceEvent::setState(const ApiTraceState &state)
+{
+    m_state = state;
+}
+
+bool ApiTraceCall::hasBinaryData() const
+{
+    return m_hasBinaryData;
+}
+
+int ApiTraceCall::binaryDataIndex() const
+{
+    return m_binaryDataIndex;
+}
+
+ApiTraceState::ApiTraceState()
+{
+}
+
+ApiTraceState::ApiTraceState(const QVariantMap &parsedJson)
+{
+    m_parameters = parsedJson[QLatin1String("parameters")].toMap();
+    QVariantMap currentProgram =
+        parsedJson[QLatin1String("current_program")].toMap();
+    QVariantList attachedShaders =
+        currentProgram[QLatin1String("attached_shaders")].toList();
+
+
+    for (int i = 0; i < attachedShaders.count(); ++i) {
+        QVariantMap var = attachedShaders[i].toMap();
+        m_shaderSources.append(
+            var[QLatin1String("source")].toString());
+    }
+
+    QVariantList textureUnits =
+        parsedJson[QLatin1String("textures")].toList();
+    for (int i = 0; i < textureUnits.count(); ++i) {
+        QVariantMap unit = textureUnits[i].toMap();
+        QVariantMap::const_iterator itr;
+        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();
+                    int numChannels =
+                        image[QLatin1String("__channels__")].toInt();
+                    QString encoding =
+                        image[QLatin1String("__encoding__")].toString();
+
+                    Q_ASSERT(numChannels == 4);
+                    Q_ASSERT(encoding == QLatin1String("base64"));
+                    Q_ASSERT(type == QLatin1String("float"));
+
+                    QByteArray dataArray =
+                        image[QLatin1String("__data__")].toByteArray();
+
+                    ApiTexture tex;
+                    tex.setSize(size);
+                    tex.setLevel(j);
+                    tex.setUnit(i);
+                    tex.setTarget(itr.key());
+                    tex.contentsFromBase64(dataArray);
+
+                    m_textures.append(tex);
+                }
+            }
+        }
+    }
+}
+
+QVariantMap ApiTraceState::parameters() const
+{
+    return m_parameters;
+}
+
+QStringList ApiTraceState::shaderSources() const
+{
+    return m_shaderSources;
+}
+
+bool ApiTraceState::isEmpty() const
+{
+    return m_parameters.isEmpty();
+}
+
+QList<ApiTexture> ApiTraceState::textures() const
+{
+    return m_textures;
+}
+
+