Parse Buffer in custom materials

and fix them up for effects. Having maps with value type of PassBuffer
would lead to slicing instances of the subclasses (e.g. an ImageBuffer)
when placing such objects into the container. Avoid this.

Task-number: QT3DS-586
Change-Id: Iaf68345cc34cd51a0c8af691dd80d6ad3149a89e
Reviewed-by: Andy Nichols <andy.nichols@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

7 files changed, 210 insertions, 170 deletions

diff --git a/src/runtime/q3dscustommaterial.cpp b/src/runtime/q3dscustommaterial.cpp
index 9326c11..48fb1db 100644
--- a/src/runtime/q3dscustommaterial.cpp
+++ b/src/runtime/q3dscustommaterial.cpp
@@ -89,16 +89,21 @@ QString Q3DSCustomMaterial::shadersSharedCode() const
     return m_shadersSharedCode;
 }
 
-QVector<Q3DSMaterial::Shader> Q3DSCustomMaterial::shaders() const
+const QVector<Q3DSMaterial::Shader> &Q3DSCustomMaterial::shaders() const
 {
     return m_shaders;
 }
 
-QVector<Q3DSMaterial::Pass> Q3DSCustomMaterial::passes() const
+const QVector<Q3DSMaterial::Pass> &Q3DSCustomMaterial::passes() const
 {
     return m_passes;
 }
 
+const QHash<QString, Q3DSMaterial::Buffer> &Q3DSCustomMaterial::buffers() const
+{
+    return m_buffers;
+}
+
 Qt3DRender::QMaterial *Q3DSCustomMaterial::generateMaterial()
 {
     auto material = new Qt3DRender::QMaterial();
@@ -544,9 +549,8 @@ void Q3DSCustomMaterialParser::parsePasses()
                         m_material.m_shaderKey = value;
                 }
             }
-            while (r->readNextStartElement()) {
+            while (r->readNextStartElement())
                 r->skipCurrentElement();
-            }
         } else if (r->name() == QStringLiteral("LayerKey")) {
             for (auto attribute : r->attributes()) {
                 if (attribute.name() == QStringLiteral("count")) {
@@ -555,14 +559,10 @@ void Q3DSCustomMaterialParser::parsePasses()
                         m_material.m_layerCount = count;
                 }
             }
-            while (r->readNextStartElement()) {
+            while (r->readNextStartElement())
                 r->skipCurrentElement();
-            }
         } else if (r->name() == QStringLiteral("Buffer")) {
-            // ### parse Buffer
-            while (r->readNextStartElement()) {
-                r->skipCurrentElement();
-            }
+            parseBuffer();
         } else {
             r->skipCurrentElement();
         }
@@ -691,6 +691,13 @@ void Q3DSCustomMaterialParser::parsePass()
     m_material.m_passes.append(pass);
 }
 
+void Q3DSCustomMaterialParser::parseBuffer()
+{
+    QXmlStreamReader *r = reader();
+    Q3DSMaterial::Buffer buffer = Q3DSMaterial::parseBuffer(r);
+    m_material.m_buffers.insert(buffer.name(), buffer);
+}
+
 bool Q3DSCustomMaterialParser::isPropertyNameUnique(const QString &name)
 {
     for (auto property : m_material.m_properties) {
diff --git a/src/runtime/q3dscustommaterial.h b/src/runtime/q3dscustommaterial.h
index c1947d7..bafaad3 100644
--- a/src/runtime/q3dscustommaterial.h
+++ b/src/runtime/q3dscustommaterial.h
@@ -63,8 +63,9 @@ public:
     QString shaderType() const;
     QString shadersVersion() const;
     QString shadersSharedCode() const;
-    QVector<Q3DSMaterial::Shader> shaders() const;
-    QVector<Q3DSMaterial::Pass> passes() const;
+    const QVector<Q3DSMaterial::Shader> &shaders() const;
+    const QVector<Q3DSMaterial::Pass> &passes() const;
+    const QHash<QString, Q3DSMaterial::Buffer> &buffers() const;
 
     Qt3DRender::QMaterial *generateMaterial();
 
@@ -111,6 +112,7 @@ private:
 
     // Passes
     QVector<Q3DSMaterial::Pass> m_passes;
+    QHash<QString, Q3DSMaterial::Buffer> m_buffers;
     quint32 m_layerCount;
     // these two are set based on Blending and Buffer stuff, not related to the shader key
     bool m_hasTransparency;
@@ -145,6 +147,7 @@ private:
     void parseShader();
     void parsePasses();
     void parsePass();
+    void parseBuffer();
 
     bool isPropertyNameUnique(const QString &name);
 
diff --git a/src/runtime/q3dseffect.cpp b/src/runtime/q3dseffect.cpp
index db6826f..7b923aa 100644
--- a/src/runtime/q3dseffect.cpp
+++ b/src/runtime/q3dseffect.cpp
@@ -58,7 +58,7 @@ const QMap<QString, Q3DSMaterial::Shader> &Q3DSEffect::shaders() const
     return m_shaders;
 }
 
-const QMap<QString, Q3DSMaterial::PassBuffers> &Q3DSEffect::buffers() const
+const QMap<QString, Q3DSMaterial::PassBuffer> &Q3DSEffect::buffers() const
 {
     return m_buffers;
 }
@@ -332,41 +332,9 @@ void Q3DSEffectParser::parsePass(Q3DSEffect &effect)
 
 void Q3DSEffectParser::parseBuffer(Q3DSEffect &effect)
 {
-    Q3DSMaterial::Buffer buffer;
     QXmlStreamReader *r = reader();
-    for (auto attribute : r->attributes()) {
-        if (attribute.name() == QStringLiteral("name")) {
-            buffer.setName(attribute.value().toString());
-        } else if (attribute.name() == QStringLiteral("lifetime")) {
-            buffer.setHasSceneLifetime(attribute.value().toString() == QStringLiteral("scene"));
-        } else if (attribute.name() == QStringLiteral("type")) {
-            buffer.setType(attribute.value().toString());
-        } else if (attribute.name() == QStringLiteral("format")) {
-            buffer.setFormat(attribute.value().toString());
-        } else if (attribute.name() == QStringLiteral("filter")) {
-            Q3DSMaterial::FilterType filter;
-            if (Q3DSMaterial::convertToFilterType(attribute.value(), &filter, "filter", r))
-                buffer.setFilter(filter);
-        } else if (attribute.name() == QStringLiteral("wrap")) {
-            Q3DSMaterial::ClampType wrap;
-            if (Q3DSMaterial::convertToClampType(attribute.value(), &wrap, "wrap", r))
-                buffer.setWrap(wrap);
-        } else if (attribute.name() == QStringLiteral("size")) {
-            float size;
-            if (Q3DS::convertToFloat(attribute.value(), &size, "size", r))
-                buffer.setSize(size);
-        }
-    }
-    // Try and resolve TextureFormat
-    Q3DSMaterial::TextureFormat format;
-    const QString formatStr = buffer.format();
-    if (Q3DSMaterial::convertToTextureFormat(&formatStr, buffer.type(), &format, "texture format", r)) {
-        buffer.setTextureFormat(format);
-    }
+    Q3DSMaterial::Buffer buffer = Q3DSMaterial::parseBuffer(r);
     effect.m_buffers.insert(buffer.name(), buffer);
-
-    while (r->readNextStartElement())
-        r->skipCurrentElement();
 }
 
 void Q3DSEffectParser::parseImage(Q3DSEffect &effect)
diff --git a/src/runtime/q3dseffect.h b/src/runtime/q3dseffect.h
index bfb0d96..d1d2bce 100644
--- a/src/runtime/q3dseffect.h
+++ b/src/runtime/q3dseffect.h
@@ -44,7 +44,7 @@ public:
     const QMap<QString, Q3DSMaterial::PropertyElement>& properties() const;
     const QString &sharedShaderCode() const;
     const QMap<QString, Q3DSMaterial::Shader>& shaders() const;
-    const QMap<QString, Q3DSMaterial::PassBuffers>& buffers() const;
+    const QMap<QString, Q3DSMaterial::PassBuffer>& buffers() const;
     const QVector<Q3DSMaterial::Pass> &passes() const;
 
 private:
@@ -52,7 +52,7 @@ private:
 
     QString m_sharedShaderCode;
     QMap<QString, Q3DSMaterial::Shader> m_shaders;
-    QMap<QString, Q3DSMaterial::PassBuffers> m_buffers;
+    QMap<QString, Q3DSMaterial::PassBuffer> m_buffers; // value type is the base class, subclasses have no data
     QVector<Q3DSMaterial::Pass> m_passes;
 
     friend class Q3DSEffectParser;
diff --git a/src/runtime/q3dsmaterial.cpp b/src/runtime/q3dsmaterial.cpp
index 7158808..48152cb 100644
--- a/src/runtime/q3dsmaterial.cpp
+++ b/src/runtime/q3dsmaterial.cpp
@@ -124,147 +124,117 @@ bool convertToClampType(const QStringRef &value, ClampType *type, const char *de
     return ok;
 }
 
-QString PassBuffers::name() const
+QString PassBuffer::name() const
 {
     return m_name;
 }
 
-void PassBuffers::setName(const QString &name)
+void PassBuffer::setName(const QString &name)
 {
     m_name = name;
 }
 
-QString PassBuffers::type() const
+QString PassBuffer::type() const
 {
     return m_type;
 }
 
-void PassBuffers::setType(const QString &type)
+void PassBuffer::setType(const QString &type)
 {
     m_type = type;
 }
 
-QString PassBuffers::format() const
+QString PassBuffer::format() const
 {
     return m_format;
 }
 
-void PassBuffers::setFormat(const QString &format)
+void PassBuffer::setFormat(const QString &format)
 {
     m_format = format;
 }
 
-float PassBuffers::size() const
+float PassBuffer::size() const
 {
     return m_size;
 }
 
-void PassBuffers::setSize(float size)
+void PassBuffer::setSize(float size)
 {
     m_size = size;
 }
 
-bool PassBuffers::hasSceneLifetime() const
+bool PassBuffer::hasSceneLifetime() const
 {
     return m_hasSceneLifetime;
 }
 
-void PassBuffers::setHasSceneLifetime(bool hasSceneLifetime)
+void PassBuffer::setHasSceneLifetime(bool hasSceneLifetime)
 {
     m_hasSceneLifetime = hasSceneLifetime;
 }
 
-PassBuffersType PassBuffers::passBufferType() const
+PassBufferType PassBuffer::passBufferType() const
 {
     return m_passBufferType;
 }
 
-FilterType Buffer::filter() const
+FilterType PassBuffer::filter() const
 {
     return m_filter;
 }
 
-void Buffer::setFilter(const FilterType &filter)
+void PassBuffer::setFilter(const FilterType &filter)
 {
     m_filter = filter;
 }
 
-ClampType Buffer::wrap() const
+ClampType PassBuffer::wrap() const
 {
     return m_wrap;
 }
 
-void Buffer::setWrap(const ClampType &wrap)
+void PassBuffer::setWrap(const ClampType &wrap)
 {
     m_wrap = wrap;
 }
 
-TextureFormat Buffer::textureFormat() const
+TextureFormat PassBuffer::textureFormat() const
 {
     return m_textureFormat;
 }
 
-void Buffer::setTextureFormat(const TextureFormat &textureFormat)
+void PassBuffer::setTextureFormat(const TextureFormat &textureFormat)
 {
     m_textureFormat = textureFormat;
 }
 
-FilterType ImageBuffer::filter() const
-{
-    return m_filter;
-}
-
-void ImageBuffer::setFilter(const FilterType &filter)
-{
-    m_filter = filter;
-}
-
-ClampType ImageBuffer::wrap() const
-{
-    return m_wrap;
-}
-
-void ImageBuffer::setWrap(const ClampType &wrap)
-{
-    m_wrap = wrap;
-}
-
-ImageAccess ImageBuffer::access() const
+ImageAccess PassBuffer::access() const
 {
     return m_access;
 }
 
-void ImageBuffer::setAccess(ImageAccess access)
+void PassBuffer::setAccess(ImageAccess access)
 {
     m_access = access;
 }
 
-TextureFormat ImageBuffer::textureFormat() const
-{
-    return m_textureFormat;
-}
-
-void ImageBuffer::setTextureFormat(const TextureFormat &textureFormat)
-{
-    m_textureFormat = textureFormat;
-}
-
-QString DataBuffer::wrapName() const
+QString PassBuffer::wrapName() const
 {
     return m_wrapName;
 }
 
-void DataBuffer::setWrapName(const QString &wrapName)
+void PassBuffer::setWrapName(const QString &wrapName)
 {
     m_wrapName = wrapName;
 }
 
-QString DataBuffer::wrapType() const
+QString PassBuffer::wrapType() const
 {
     return m_wrapType;
 }
 
-void DataBuffer::setWrapType(const QString &wrapType)
+void PassBuffer::setWrapType(const QString &wrapType)
 {
     m_wrapType = wrapType;
 }
@@ -372,6 +342,46 @@ Shader parserShaderElement(QXmlStreamReader *r)
     return shader;
 }
 
+Buffer parseBuffer(QXmlStreamReader *r)
+{
+    Q3DSMaterial::Buffer buffer;
+
+    for (auto attribute : r->attributes()) {
+        if (attribute.name() == QStringLiteral("name")) {
+            buffer.setName(attribute.value().toString());
+        } else if (attribute.name() == QStringLiteral("lifetime")) {
+            buffer.setHasSceneLifetime(attribute.value().toString() == QStringLiteral("scene"));
+        } else if (attribute.name() == QStringLiteral("type")) {
+            buffer.setType(attribute.value().toString());
+        } else if (attribute.name() == QStringLiteral("format")) {
+            buffer.setFormat(attribute.value().toString());
+        } else if (attribute.name() == QStringLiteral("filter")) {
+            Q3DSMaterial::FilterType filter;
+            if (Q3DSMaterial::convertToFilterType(attribute.value(), &filter, "filter", r))
+                buffer.setFilter(filter);
+        } else if (attribute.name() == QStringLiteral("wrap")) {
+            Q3DSMaterial::ClampType wrap;
+            if (Q3DSMaterial::convertToClampType(attribute.value(), &wrap, "wrap", r))
+                buffer.setWrap(wrap);
+        } else if (attribute.name() == QStringLiteral("size")) {
+            float size;
+            if (Q3DS::convertToFloat(attribute.value(), &size, "size", r))
+                buffer.setSize(size);
+        }
+    }
+
+    // Try to resolve the texture format. "source" is handled specially and resolves to Unknown.
+    Q3DSMaterial::TextureFormat format;
+    const QString formatStr = buffer.format();
+    if (Q3DSMaterial::convertToTextureFormat(&formatStr, buffer.type(), &format, "texture format", r))
+        buffer.setTextureFormat(format);
+
+    while (r->readNextStartElement())
+        r->skipCurrentElement();
+
+    return buffer;
+}
+
 QString filterTypeToString(FilterType type)
 {
     QString filterString;
diff --git a/src/runtime/q3dsmaterial.h b/src/runtime/q3dsmaterial.h
index c5b2767..70e1144 100644
--- a/src/runtime/q3dsmaterial.h
+++ b/src/runtime/q3dsmaterial.h
@@ -155,8 +155,6 @@ struct Q3DSV_EXPORT PropertyElement
     {}
 };
 
-Q_DECLARE_TYPEINFO(PropertyElement, Q_MOVABLE_TYPE);
-
 struct Q3DSV_EXPORT Shader // or rather, program
 {
     QString name;
@@ -165,38 +163,29 @@ struct Q3DSV_EXPORT Shader // or rather, program
     QString fragmentShader;
 };
 
-Q_DECLARE_TYPEINFO(Shader, Q_MOVABLE_TYPE);
-
-enum PassBuffersType {
+enum PassBufferType {
     UnknownBufferType,
     BufferType,
     ImageType,
     DataBufferType
 };
 
-class Q3DSV_EXPORT PassBuffers
+class Q3DSV_EXPORT PassBuffer
 {
 public:
-    PassBuffers(PassBuffersType type_)
+    PassBuffer(PassBufferType type_ = UnknownBufferType)
         : m_passBufferType(type_)
-        , m_size(1.0f)
-        , m_hasSceneLifetime(false)
-    {}
-    PassBuffers()
-        : m_passBufferType(UnknownBufferType)
-        , m_size(1.0f)
-        , m_hasSceneLifetime(false)
     {}
 
     QString name() const;
     void setName(const QString &name);
 
-    PassBuffersType passBufferType() const;
+    PassBufferType passBufferType() const;
 
     QString type() const;
     void setType(const QString &type);
 
-    QString format() const;
+    QString format() const; // "source" or a texture format
     void setFormat(const QString &format);
 
     float size() const;
@@ -205,67 +194,24 @@ public:
     bool hasSceneLifetime() const;
     void setHasSceneLifetime(bool hasSceneLifetime);
 
-private:
-    QString m_name;
-    PassBuffersType m_passBufferType;
-    QString m_type;
-    QString m_format;
-    float m_size;
-    bool m_hasSceneLifetime;
-};
-
-Q_DECLARE_TYPEINFO(PassBuffers, Q_MOVABLE_TYPE);
+    // Buffer + Image
 
-class Q3DSV_EXPORT Buffer : public PassBuffers
-{
-public:
-    Buffer() : PassBuffers(PassBuffersType::BufferType) {}
     FilterType filter() const;
     void setFilter(const FilterType &filter);
 
     ClampType wrap() const;
     void setWrap(const ClampType &wrap);
 
-    TextureFormat textureFormat() const;
+    TextureFormat textureFormat() const; // unknown when format() == "source", a valid format otherwise
     void setTextureFormat(const TextureFormat &textureFormat);
 
-private:
-    FilterType m_filter;
-    ClampType m_wrap;
-    TextureFormat m_textureFormat;
-};
-
-Q_DECLARE_TYPEINFO(Buffer, Q_MOVABLE_TYPE);
-
-class Q3DSV_EXPORT ImageBuffer : public PassBuffers
-{
-public:
-    ImageBuffer() : PassBuffers(PassBuffersType::ImageType) {}
-    FilterType filter() const;
-    void setFilter(const FilterType &filter);
-
-    ClampType wrap() const;
-    void setWrap(const ClampType &wrap);
+    // Image
 
     ImageAccess access() const;
     void setAccess(ImageAccess access);
 
-    TextureFormat textureFormat() const;
-    void setTextureFormat(const TextureFormat &textureFormat);
-
-private:
-    FilterType m_filter;
-    ClampType m_wrap;
-    ImageAccess m_access;
-    TextureFormat m_textureFormat;
-};
-
-Q_DECLARE_TYPEINFO(ImageBuffer, Q_MOVABLE_TYPE);
+    // DataBuffer
 
-class Q3DSV_EXPORT DataBuffer : public PassBuffers
-{
-public:
-    DataBuffer() : PassBuffers(PassBuffersType::DataBufferType) {}
     QString wrapName() const;
     void setWrapName(const QString &wrapName);
 
@@ -273,11 +219,42 @@ public:
     void setWrapType(const QString &wrapType);
 
 private:
+    QString m_name;
+    PassBufferType m_passBufferType = UnknownBufferType;
+    QString m_type;
+    QString m_format;
+    float m_size = 1.0f;
+    bool m_hasSceneLifetime = false;
+
+    FilterType m_filter = Nearest;
+    ClampType m_wrap = Clamp;
+    TextureFormat m_textureFormat = UnknownTextureFormat;
+
+    ImageAccess m_access = Read;
+
     QString m_wrapName;
     QString m_wrapType;
 };
 
-Q_DECLARE_TYPEINFO(DataBuffer, Q_MOVABLE_TYPE);
+// no data allowed in the PassBuffer subclasses in order to avoid object slicing
+
+class Q3DSV_EXPORT Buffer : public PassBuffer
+{
+public:
+    Buffer() : PassBuffer(PassBufferType::BufferType) {}
+};
+
+class Q3DSV_EXPORT ImageBuffer : public PassBuffer
+{
+public:
+    ImageBuffer() : PassBuffer(PassBufferType::ImageType) {}
+};
+
+class Q3DSV_EXPORT DataBuffer : public PassBuffer
+{
+public:
+    DataBuffer() : PassBuffer(PassBufferType::DataBufferType) {}
+};
 
 enum BoolOp {
     Never,
@@ -346,9 +323,6 @@ private:
     Data m_data;
 };
 
-Q_DECLARE_TYPEINFO(PassCommand::Data, Q_MOVABLE_TYPE);
-Q_DECLARE_TYPEINFO(PassCommand, Q_MOVABLE_TYPE);
-
 struct Q3DSV_EXPORT Pass
 {
     QString shaderName;
@@ -366,10 +340,10 @@ struct Q3DSV_EXPORT Pass
     {}
 };
 
-Q_DECLARE_TYPEINFO(Pass, Q_MOVABLE_TYPE);
-
+// parsing code common between custom materials and effects
 PropertyElement parserPropertyElement(QXmlStreamReader *r);
 Shader parserShaderElement(QXmlStreamReader *r);
+Buffer parseBuffer(QXmlStreamReader *r);
 
 bool convertToUsageType(const QStringRef &value, Q3DSMaterial::UsageType *type, const char *desc, QXmlStreamReader *reader = nullptr);
 bool convertToFilterType(const QStringRef &value, Q3DSMaterial::FilterType *type, const char *desc, QXmlStreamReader *reader = nullptr);
@@ -381,6 +355,16 @@ bool convertToBlendFunc(const QStringRef &value, Q3DSMaterial::BlendFunc *type,
 bool convertToImageAccess(const QStringRef &value, Q3DSMaterial::ImageAccess *type, const char *desc, QXmlStreamReader *reader = nullptr);
 }
 
+Q_DECLARE_TYPEINFO(Q3DSMaterial::PropertyElement, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Q3DSMaterial::Shader, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Q3DSMaterial::PassBuffer, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Q3DSMaterial::Buffer, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Q3DSMaterial::ImageBuffer, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Q3DSMaterial::DataBuffer, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Q3DSMaterial::PassCommand::Data, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Q3DSMaterial::PassCommand, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Q3DSMaterial::Pass, Q_MOVABLE_TYPE);
+
 QT_END_NAMESPACE
 
 #endif // Q3DSMATERIAL_H
diff --git a/tests/auto/materialparser/tst_q3dscustommaterialparser.cpp b/tests/auto/materialparser/tst_q3dscustommaterialparser.cpp
index 98ce701..216134e 100644
--- a/tests/auto/materialparser/tst_q3dscustommaterialparser.cpp
+++ b/tests/auto/materialparser/tst_q3dscustommaterialparser.cpp
@@ -47,6 +47,7 @@ private Q_SLOTS:
     void testValidateData();
     void testMaterialGeneration();
     void testCommands();
+    void testBuffers();
 };
 
 tst_Q3DSCustomMaterialParser::tst_Q3DSCustomMaterialParser()
@@ -253,6 +254,73 @@ void tst_Q3DSCustomMaterialParser::testCommands()
     QCOMPARE(cmd.data()->destination, QLatin1String("OneMinusSrcAlpha"));
 }
 
+void tst_Q3DSCustomMaterialParser::testBuffers()
+{
+    Q3DSCustomMaterialParser parser;
+    Q3DSCustomMaterial customMaterial;
+    bool ok = false;
+
+    customMaterial = parser.parse(QStringLiteral(":/data/thin_glass_frosted.material"), &ok);
+    QVERIFY(ok);
+    QVERIFY(!customMaterial.isNull());
+
+    QCOMPARE(customMaterial.shaders().count(), 5);
+    QCOMPARE(customMaterial.passes().count(), 5);
+    QCOMPARE(customMaterial.buffers().count(), 5);
+
+    auto buffers = customMaterial.buffers();
+    QVERIFY(buffers.contains(QLatin1String("frame_buffer")));
+    QVERIFY(buffers.contains(QLatin1String("dummy_buffer")));
+    QVERIFY(buffers.contains(QLatin1String("temp_buffer")));
+    QVERIFY(buffers.contains(QLatin1String("temp_blurX")));
+    QVERIFY(buffers.contains(QLatin1String("temp_blurY")));
+
+    Q3DSMaterial::Buffer b = buffers.value(QLatin1String("frame_buffer"));
+    QCOMPARE(b.format(), QStringLiteral("source"));
+    QCOMPARE(b.type(), QString());
+    QCOMPARE(b.textureFormat(), Q3DSMaterial::UnknownTextureFormat);
+    QCOMPARE(b.filter(), Q3DSMaterial::Linear);
+    QCOMPARE(b.wrap(), Q3DSMaterial::Clamp);
+    QCOMPARE(b.size(), 1.0f);
+    QCOMPARE(b.hasSceneLifetime(), false);
+
+    b = buffers.value(QLatin1String("dummy_buffer"));
+    QCOMPARE(b.format(), QStringLiteral("rgba"));
+    QCOMPARE(b.type(), QStringLiteral("ubyte"));
+    QCOMPARE(b.textureFormat(), Q3DSMaterial::RGBA8);
+    QCOMPARE(b.filter(), Q3DSMaterial::Nearest);
+    QCOMPARE(b.wrap(), Q3DSMaterial::Clamp);
+    QCOMPARE(b.size(), 1.0f);
+    QCOMPARE(b.hasSceneLifetime(), false);
+
+    b = buffers.value(QLatin1String("temp_buffer"));
+    QCOMPARE(b.format(), QStringLiteral("rgba"));
+    QCOMPARE(b.type(), QStringLiteral("fp16"));
+    QCOMPARE(b.textureFormat(), Q3DSMaterial::RGBA16F);
+    QCOMPARE(b.filter(), Q3DSMaterial::Linear);
+    QCOMPARE(b.wrap(), Q3DSMaterial::Clamp);
+    QCOMPARE(b.size(), 0.5f);
+    QCOMPARE(b.hasSceneLifetime(), false);
+
+    b = buffers.value(QLatin1String("temp_blurX"));
+    QCOMPARE(b.format(), QStringLiteral("rgba"));
+    QCOMPARE(b.type(), QStringLiteral("fp16"));
+    QCOMPARE(b.textureFormat(), Q3DSMaterial::RGBA16F);
+    QCOMPARE(b.filter(), Q3DSMaterial::Linear);
+    QCOMPARE(b.wrap(), Q3DSMaterial::Clamp);
+    QCOMPARE(b.size(), 0.5f);
+    QCOMPARE(b.hasSceneLifetime(), false);
+
+    b = buffers.value(QLatin1String("temp_blurY"));
+    QCOMPARE(b.format(), QStringLiteral("rgba"));
+    QCOMPARE(b.type(), QStringLiteral("fp16"));
+    QCOMPARE(b.textureFormat(), Q3DSMaterial::RGBA16F);
+    QCOMPARE(b.filter(), Q3DSMaterial::Linear);
+    QCOMPARE(b.wrap(), Q3DSMaterial::Clamp);
+    QCOMPARE(b.size(), 0.5f);
+    QCOMPARE(b.hasSceneLifetime(), false);
+}
+
 QTEST_MAIN(tst_Q3DSCustomMaterialParser)
 
 #include "tst_q3dscustommaterialparser.moc"