+
+void VariantVisitor::visit(trace::Null *)
+{
+ m_variant = QVariant::fromValue(ApiPointer(0));
+}
+
+void VariantVisitor::visit(trace::Bool *node)
+{
+ m_variant = QVariant(node->value);
+}
+
+void VariantVisitor::visit(trace::SInt *node)
+{
+ m_variant = QVariant(node->value);
+}
+
+void VariantVisitor::visit(trace::UInt *node)
+{
+ m_variant = QVariant(node->value);
+}
+
+void VariantVisitor::visit(trace::Float *node)
+{
+ m_variant = QVariant(node->value);
+}
+
+void VariantVisitor::visit(trace::Double *node)
+{
+ m_variant = QVariant(node->value);
+}
+
+void VariantVisitor::visit(trace::String *node)
+{
+ m_variant = QVariant(QString::fromStdString(node->value));
+}
+
+void VariantVisitor::visit(trace::Enum *e)
+{
+ ApiTraceEnumSignature *sig = 0;
+
+ if (m_loader) {
+ sig = m_loader->enumSignature(e->sig->id);
+ }
+ if (!sig) {
+ sig = new ApiTraceEnumSignature(e->sig);
+ if (m_loader) {
+ m_loader->addEnumSignature(e->sig->id, sig);
+ }
+ }
+
+ m_variant = QVariant::fromValue(ApiEnum(sig, e->value));
+}
+
+void VariantVisitor::visit(trace::Bitmask *bitmask)
+{
+ m_variant = QVariant::fromValue(ApiBitmask(bitmask));
+}
+
+void VariantVisitor::visit(trace::Struct *str)
+{
+ m_variant = QVariant::fromValue(ApiStruct(str));
+}
+
+void VariantVisitor::visit(trace::Array *array)
+{
+ m_variant = QVariant::fromValue(ApiArray(array));
+}
+
+void VariantVisitor::visit(trace::Blob *blob)
+{
+ QByteArray barray = QByteArray(blob->buf, blob->size);
+ m_variant = QVariant(barray);
+}
+
+void VariantVisitor::visit(trace::Pointer *ptr)
+{
+ m_variant = QVariant::fromValue(ApiPointer(ptr->value));
+}
+
+void VariantVisitor::visit(trace::Repr *repr)
+{
+ /* TODO: Preserve both the human and machine value */
+ repr->humanValue->visit(*this);
+}
+
+ApiTraceEnumSignature::ApiTraceEnumSignature(const trace::EnumSig *sig)
+{
+ for (const trace::EnumValue *it = sig->values;
+ it != sig->values + sig->num_values; ++it) {
+ QPair<QString, signed long long> pair;
+
+ pair.first = QString::fromStdString(it->name);
+ pair.second = it->value;
+
+ m_names.append(pair);
+ }
+}
+
+QString ApiTraceEnumSignature::name(signed long long value) const
+{
+ for (ValueList::const_iterator it = m_names.begin();
+ it != m_names.end(); ++it) {
+ if (value == it->second) {
+ return it->first;
+ }
+ }
+ return QString::fromLatin1("%1").arg(value);
+}
+
+ApiEnum::ApiEnum(ApiTraceEnumSignature *sig, signed long long value)
+ : m_sig(sig), m_value(value)
+{
+}
+
+QString ApiEnum::toString() const
+{
+ if (m_sig) {
+ return m_sig->name(m_value);
+ }
+ Q_ASSERT(!"should never happen");
+ return QString();
+}
+
+QVariant ApiEnum::value() const
+{
+ if (m_sig) {
+ return QVariant::fromValue(m_value);
+ }
+ Q_ASSERT(!"should never happen");
+ return QVariant();
+}
+
+QString ApiEnum::name() const
+{
+ if (m_sig) {
+ return m_sig->name(m_value);
+ }
+ Q_ASSERT(!"should never happen");
+ return QString();
+}
+
+unsigned long long ApiBitmask::value() const
+{
+ return m_value;
+}
+
+ApiBitmask::Signature ApiBitmask::signature() const
+{
+ return m_sig;
+}
+
+ApiStruct::Signature ApiStruct::signature() const
+{
+ return m_sig;
+}
+
+QList<QVariant> ApiStruct::values() const
+{
+ return m_members;
+}
+
+ApiPointer::ApiPointer(unsigned long long val)
+ : m_value(val)
+{
+}
+
+
+unsigned long long ApiPointer::value() const
+{
+ return m_value;
+}
+
+QString ApiPointer::toString() const
+{
+ if (m_value)
+ return QString("0x%1").arg(m_value, 0, 16);
+ else
+ return QLatin1String("NULL");
+}
+
+ApiBitmask::ApiBitmask(const trace::Bitmask *bitmask)
+ : m_value(0)
+{
+ init(bitmask);
+}
+
+void ApiBitmask::init(const trace::Bitmask *bitmask)
+{
+ if (!bitmask)
+ return;
+
+ m_value = bitmask->value;
+ for (const trace::BitmaskFlag *it = bitmask->sig->flags;
+ it != bitmask->sig->flags + bitmask->sig->num_flags; ++it) {
+ QPair<QString, unsigned long long> pair;
+
+ pair.first = QString::fromStdString(it->name);
+ pair.second = it->value;
+
+ m_sig.append(pair);
+ }
+}
+
+QString ApiBitmask::toString() const
+{
+ QString str;
+ unsigned long long value = m_value;
+ bool first = true;
+ for (Signature::const_iterator it = m_sig.begin(); it != m_sig.end(); ++it) {
+ Q_ASSERT(it->second || first);
+ if ((it->second && (value & it->second) == it->second) ||
+ (!it->second && value == 0)) {
+ if (!first) {
+ str += QLatin1String(" | ");
+ }
+ str += it->first;
+ value &= ~it->second;
+ first = false;
+ }
+ if (value == 0) {
+ break;
+ }
+ }
+ if (value || first) {
+ if (!first) {
+ str += QLatin1String(" | ");
+ }
+ str += QString::fromLatin1("0x%1").arg(value, 0, 16);
+ }
+ return str;
+}
+
+ApiStruct::ApiStruct(const trace::Struct *s)
+{
+ init(s);
+}
+
+QString ApiStruct::toString(bool multiLine) const
+{
+ QString str;
+
+ str += QLatin1String("{");
+ for (unsigned i = 0; i < m_members.count(); ++i) {
+ str += m_sig.memberNames[i] %
+ QLatin1Literal(" = ") %
+ apiVariantToString(m_members[i], multiLine);
+ if (i < m_members.count() - 1)
+ str += QLatin1String(", ");
+ }
+ str += QLatin1String("}");
+
+ return str;
+}
+
+void ApiStruct::init(const trace::Struct *s)
+{
+ if (!s)
+ return;
+
+ m_sig.name = QString::fromStdString(s->sig->name);
+ for (unsigned i = 0; i < s->sig->num_members; ++i) {
+ VariantVisitor vis(0);
+ m_sig.memberNames.append(
+ QString::fromStdString(s->sig->member_names[i]));
+ s->members[i]->visit(vis);
+ m_members.append(vis.variant());
+ }
+}
+
+ApiArray::ApiArray(const trace::Array *arr)
+{
+ init(arr);
+}
+
+ApiArray::ApiArray(const QVector<QVariant> &vals)
+ : m_array(vals)
+{
+}
+
+QVector<QVariant> ApiArray::values() const
+{
+ return m_array;
+}
+
+QString ApiArray::toString(bool multiLine) const
+{
+ QString str;
+ str += QLatin1String("[");
+ for(int i = 0; i < m_array.count(); ++i) {
+ const QVariant &var = m_array[i];
+ str += apiVariantToString(var, multiLine);
+ if (i < m_array.count() - 1)
+ str += QLatin1String(", ");
+ }
+ str += QLatin1String("]");
+
+ return str;
+}
+
+void ApiArray::init(const trace::Array *arr)
+{
+ if (!arr)
+ return;
+
+ m_array.reserve(arr->values.size());
+ for (int i = 0; i < arr->values.size(); ++i) {
+ VariantVisitor vis(0);
+ arr->values[i]->visit(vis);
+
+ m_array.append(vis.variant());
+ }
+ m_array.squeeze();
+}
+
+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;
+ }
+
+ m_uniforms = parsedJson[QLatin1String("uniforms")].toMap();
+
+ QVariantMap textures =
+ parsedJson[QLatin1String("textures")].toMap();
+ for (itr = textures.constBegin(); itr != textures.constEnd(); ++itr) {
+ QVariantMap image = itr.value().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();
+ int depth =
+ image[QLatin1String("__depth__")].toInt();
+ QString formatName =
+ image[QLatin1String("__format__")].toString();
+
+ Q_ASSERT(type == QLatin1String("uint8"));
+ Q_ASSERT(normalized == true);
+ Q_UNUSED(normalized);
+
+ QByteArray dataArray =
+ image[QLatin1String("__data__")].toByteArray();
+
+ ApiTexture tex;
+ tex.setSize(size);
+ tex.setDepth(depth);
+ tex.setFormatName(formatName);
+ tex.setNumChannels(numChannels);
+ tex.setLabel(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();
+ int depth = buffer[QLatin1String("__depth__")].toInt();
+ QString formatName = buffer[QLatin1String("__format__")].toString();
+
+ Q_ASSERT(type == QLatin1String("uint8"));
+ Q_ASSERT(normalized == true);
+ Q_UNUSED(normalized);
+
+ QByteArray dataArray =
+ buffer[QLatin1String("__data__")].toByteArray();
+
+ ApiFramebuffer fbo;
+ fbo.setSize(size);
+ fbo.setDepth(depth);
+ fbo.setFormatName(formatName);
+ fbo.setNumChannels(numChannels);
+ fbo.setType(itr.key());
+ fbo.contentsFromBase64(dataArray);
+ m_framebuffers.append(fbo);
+ }
+}
+
+const QVariantMap & ApiTraceState::parameters() const
+{
+ return m_parameters;
+}
+
+const QMap<QString, QString> & ApiTraceState::shaderSources() const
+{
+ return m_shaderSources;
+}
+
+const QVariantMap & ApiTraceState::uniforms() const
+{
+ return m_uniforms;
+}
+
+bool ApiTraceState::isEmpty() const
+{
+ return m_parameters.isEmpty();
+}
+
+const QList<ApiTexture> & ApiTraceState::textures() const
+{
+ return m_textures;
+}
+
+const QList<ApiFramebuffer> & ApiTraceState::framebuffers() const
+{
+ return m_framebuffers;
+}
+
+ApiFramebuffer ApiTraceState::colorBuffer() const
+{
+ foreach (ApiFramebuffer fbo, m_framebuffers) {
+ if (fbo.type() == QLatin1String("GL_BACK")) {
+ return fbo;
+ }
+ }
+ foreach (ApiFramebuffer fbo, m_framebuffers) {
+ if (fbo.type() == QLatin1String("GL_FRONT")) {
+ return fbo;
+ }
+ }
+ return ApiFramebuffer();
+}
+
+
+ApiTraceCallSignature::ApiTraceCallSignature(const QString &name,
+ const QStringList &argNames)
+ : m_name(name),
+ m_argNames(argNames)
+{
+}
+
+ApiTraceCallSignature::~ApiTraceCallSignature()
+{
+}
+
+QUrl ApiTraceCallSignature::helpUrl() const
+{
+ return m_helpUrl;
+}
+
+void ApiTraceCallSignature::setHelpUrl(const QUrl &url)
+{
+ m_helpUrl = url;
+}
+
+ApiTraceEvent::ApiTraceEvent()
+ : m_type(ApiTraceEvent::None),
+ m_hasBinaryData(false),
+ m_binaryDataIndex(0),
+ m_state(0),
+ m_staticText(0)
+{
+}
+
+ApiTraceEvent::ApiTraceEvent(Type t)
+ : m_type(t),
+ m_hasBinaryData(false),
+ m_binaryDataIndex(0),
+ m_state(0),
+ m_staticText(0)
+{
+}
+
+ApiTraceEvent::~ApiTraceEvent()
+{
+ delete m_state;
+ delete m_staticText;
+}
+
+QVariantMap ApiTraceEvent::stateParameters() const
+{
+ if (m_state) {
+ return m_state->parameters();
+ } else {
+ return QVariantMap();
+ }
+}
+
+ApiTraceState *ApiTraceEvent::state() const