+ 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
+{
+ return m_state;
+}
+
+void ApiTraceEvent::setState(ApiTraceState *state)
+{
+ m_state = state;
+}
+
+ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame,
+ TraceLoader *loader,
+ const trace::Call *call)
+ : ApiTraceEvent(ApiTraceEvent::Call),
+ m_parentFrame(parentFrame)
+{
+ m_index = call->no;
+
+ m_signature = loader->signature(call->sig->id);
+
+ if (!m_signature) {
+ QString name = QString::fromStdString(call->sig->name);
+ QStringList argNames;
+ argNames.reserve(call->sig->num_args);
+ for (int i = 0; i < call->sig->num_args; ++i) {
+ argNames += QString::fromStdString(call->sig->arg_names[i]);
+ }
+ m_signature = new ApiTraceCallSignature(name, argNames);
+ loader->addSignature(call->sig->id, m_signature);