qt/qtquick3d/src/runtimerender/qssgrendershaderkeys_p.h

Revision control

++ // Copyright (C) 2008-2012 NVIDIA Corporation.
++ // Copyright (C) 2019 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++
++ #ifndef QSSG_RENDER_SHADER_KEY_H
++ #define QSSG_RENDER_SHADER_KEY_H
++
++ //
++ // W A R N I N G
++ // -------------
++ //
++ // This file is not part of the Qt API. It exists purely as an
++ // implementation detail. This header file may change from version to
++ // version without notice, or even be removed.
++ //
++ // We mean it.
++ //
++
++ #include <QtQuick3DUtils/private/qssgdataref_p.h>
++ #include <QtQuick3DUtils/private/qssgrenderbasetypes_p.h>
++ #include <QtQuick3DRuntimeRender/private/qssgrenderdefaultmaterial_p.h>
++ #include <QtQuick3DRuntimeRender/private/qssgrenderlight_p.h>
++ #include <QtQuick3DRuntimeRender/private/qssgrhicontext_p.h>
++
++ QT_BEGIN_NAMESPACE
++ // We have an ever expanding set of properties we like to hash into one or more 32 bit
++ // quantities.
++ // Furthermore we would like this set of properties to be convertable to string
++ // So the shader cache file itself is somewhat human readable/diagnosable.
++ // To do this we create a set of objects that act as properties to the master shader key.
++ // These objects are tallied in order to figure out their actual offset into the shader key's
++ // data store. They are also run through in order to create the string shader cache key.
++
++ struct QSSGShaderKeyPropertyBase
++ {
++ QByteArrayView name;
++ quint32 offset;
++ explicit constexpr QSSGShaderKeyPropertyBase(const char *inName = "") : name(inName), offset(0) {}
++ quint32 getOffset() const { return offset; }
++ void setOffset(quint32 of) { offset = of; }
++
++ template<quint32 TBitWidth>
++ quint32 getMaskTemplate() const
++ {
++ quint32 bit = offset % 32;
++ quint32 startValue = (1 << TBitWidth) - 1;
++ quint32 mask = startValue << bit;
++ return mask;
++ }
++
++ quint32 getIdx() const { return offset / 32; }
++
++ protected:
++ void internalToString(QByteArray &ioStr, const QByteArrayView &inBuffer) const
++ {
++ ioStr.append(name);
++ ioStr.append('=');
++ ioStr.append(inBuffer);
++ }
++
++ static void internalToString(QByteArray &ioStr, const QByteArrayView &name, bool inValue)
++ {
++ if (inValue) {
++ ioStr.append(name);
++ ioStr.append('=');
++ ioStr.append(inValue ? QByteArrayView("true") : QByteArrayView("false"));
++ }
++ }
++ static bool getBoolValue(const QByteArray& str, const QByteArrayView &name)
++ {
++ const int index = str.indexOf(name);
++ if (index < 0)
++ return false;
++ const qsizetype nameLen = name.size();
++ if (str[index + nameLen] != '=')
++ return false;
++ if (str.mid(index + nameLen + 1, 4) == QByteArrayView("true"))
++ return true;
++ return false;
++ }
++ };
++
++ struct QSSGShaderKeyBoolean : public QSSGShaderKeyPropertyBase
++ {
++ enum {
++ BitWidth = 1,
++ };
++
++ explicit constexpr QSSGShaderKeyBoolean(const char *inName = "") : QSSGShaderKeyPropertyBase(inName) {}
++
++ quint32 getMask() const { return getMaskTemplate<BitWidth>(); }
++ void setValue(QSSGDataRef<quint32> inDataStore, bool inValue) const
++ {
++ const qint32 idx = qint32(getIdx());
++ Q_ASSERT(idx >= 0 && idx <= INT32_MAX);
++ Q_ASSERT(inDataStore.size() > idx);
++ quint32 mask = getMask();
++ quint32 &target = inDataStore[idx];
++ if (inValue) {
++ target = target | mask;
++ } else {
++ mask = ~mask;
++ target = target & mask;
++ }
++ }
++
++ bool getValue(QSSGDataView<quint32> inDataStore) const
++ {
++ quint32 idx = getIdx();
++ quint32 mask = getMask();
++ const quint32 &target = inDataStore[idx];
++ return (target & mask) ? true : false;
++ }
++
++ void toString(QByteArray &ioStr, QSSGDataView<quint32> inKeySet) const
++ {
++ bool isHigh = getValue(inKeySet);
++ internalToString(ioStr, name, isHigh);
++ }
++ void fromString(const QByteArray &ioStr, QSSGDataRef<quint32> inKeySet)
++ {
++ setValue(inKeySet, getBoolValue(ioStr, name));
++ }
++ };
++
++ template<quint32 TBitWidth>
++ struct QSSGShaderKeyUnsigned : public QSSGShaderKeyPropertyBase
++ {
++ enum {
++ BitWidth = TBitWidth,
++ };
++ explicit constexpr QSSGShaderKeyUnsigned(const char *inName = "") : QSSGShaderKeyPropertyBase(inName) {}
++ quint32 getMask() const { return getMaskTemplate<BitWidth>(); }
++ void setValue(QSSGDataRef<quint32> inDataStore, quint32 inValue) const
++ {
++ quint32 startValue = (1 << TBitWidth) - 1;
++ // Ensure inValue is within range of bit width.
++ inValue = inValue & startValue;
++ quint32 bit = offset % 32;
++ quint32 mask = getMask();
++ quint32 idx = getIdx();
++ inValue = inValue << bit;
++ quint32 &target = inDataStore[idx];
++ // Get rid of existing value
++ quint32 inverseMask = ~mask;
++ target = target & inverseMask;
++ target = target | inValue;
++ }
++
++ quint32 getValue(QSSGDataView<quint32> inDataStore) const
++ {
++ quint32 idx = getIdx();
++ quint32 bit = offset % 32;
++ quint32 mask = getMask();
++ const quint32 &target = inDataStore[idx];
++
++ quint32 retval = target & mask;
++ retval = retval >> bit;
++ return retval;
++ }
++
++ void toString(QByteArray &ioStr, QSSGDataView<quint32> inKeySet) const
++ {
++ quint32 value = getValue(inKeySet);
++ char buf[64];
++ memset(buf, 0, sizeof (buf));
++ toStr(value, toDataRef(buf, 64));
++ internalToString(ioStr, buf);
++ }
++
++ void fromString(const QByteArray &ioStr, QSSGDataRef<quint32> inKeySet)
++ {
++ const qsizetype nameLen = name.size();
++ const qsizetype strOffset = ioStr.indexOf(name);
++ if (strOffset >= 0) {
++ /* The key is stored as name=val */
++ if (ioStr[strOffset + nameLen] != '=')
++ return;
++ const QByteArray s = ioStr.right(ioStr.size() - strOffset - nameLen - 1);
++ int i = 0;
++ while (QChar(QLatin1Char(s[i])).isDigit())
++ i++;
++ const quint32 value = s.left(i).toInt();
++ setValue(inKeySet, value);
++ }
++ }
++
++ private:
++ static quint32 toStr(quint32 item, QSSGDataRef<char> buffer)
++ {
++ // hope the buffer is big enough...
++ return static_cast<quint32>(::snprintf(buffer.begin(), buffer.size(), "%u", item));
++ }
++ };
++
++ struct QSSGShaderKeyTextureChannel : public QSSGShaderKeyUnsigned<2>
++ {
++ enum TexturChannelBits {
++ R = 0,
++ G = 1,
++ B = 2,
++ A = 3,
++ };
++ explicit QSSGShaderKeyTextureChannel(const char *inName = "") : QSSGShaderKeyUnsigned<2>(inName) {}
++
++ TexturChannelBits getTextureChannel(QSSGDataView<quint32> inKeySet) const
++ {
++ return TexturChannelBits(getValue(inKeySet));
++ }
++
++ void setTextureChannel(TexturChannelBits channel, QSSGDataRef<quint32> inKeySet)
++ {
++ setValue(inKeySet, quint32(channel));
++ }
++ static constexpr char textureChannelToChar[4] = {
++ 'R',
++ 'G',
++ 'B',
++ 'A'
++ };
++ void toString(QByteArray &ioStr, QSSGDataView<quint32> inKeySet) const
++ {
++ ioStr.append(name);
++ ioStr.append('=');
++ ioStr.append(textureChannelToChar[getTextureChannel(inKeySet)]);
++ }
++ void fromString(const QByteArray &ioStr, QSSGDataRef<quint32> inKeySet)
++ {
++ const qsizetype nameLen = name.size();
++ const qsizetype strOffset = ioStr.indexOf(name);
++ if (strOffset >= 0) {
++ /* The key is stored as name=ch */
++ if (ioStr[strOffset + nameLen] != '=')
++ return;
++ const char ch = ioStr[strOffset + nameLen + 1];
++ if (ch == 'R')
++ setValue(inKeySet, TexturChannelBits::R);
++ else if (ch == 'G')
++ setValue(inKeySet, TexturChannelBits::G);
++ else if (ch == 'B')
++ setValue(inKeySet, TexturChannelBits::B);
++ else if (ch == 'A')
++ setValue(inKeySet, TexturChannelBits::A);
++ }
++ }
++ };
++
++ struct QSSGShaderKeyImageMap : public QSSGShaderKeyUnsigned<7>
++ {
++ enum ImageMapBits {
++ Enabled = 1 << 0,
++ EnvMap = 1 << 1,
++ LightProbe = 1 << 2,
++ Identity = 1 << 3,
++ UsesUV1 = 1 << 4,
++ Linear = 1 << 5,
++ PreMultipliedAlpha = 1 << 6,
++ };
++
++ explicit QSSGShaderKeyImageMap(const char *inName = "") : QSSGShaderKeyUnsigned<7>(inName) {}
++
++ bool getBitValue(ImageMapBits imageBit, QSSGDataView<quint32> inKeySet) const
++ {
++ return (getValue(inKeySet) & imageBit) ? true : false;
++ }
++
++ void setBitValue(ImageMapBits imageBit, bool inValue, QSSGDataRef<quint32> inKeySet)
++ {
++ quint32 theValue = getValue(inKeySet);
++ quint32 mask = imageBit;
++ if (inValue) {
++ theValue = theValue | mask;
++ } else {
++ mask = ~mask;
++ theValue = theValue & mask;
++ }
++ setValue(inKeySet, theValue);
++ }
++
++ bool isEnabled(QSSGDataView<quint32> inKeySet) const { return getBitValue(Enabled, inKeySet); }
++ void setEnabled(QSSGDataRef<quint32> inKeySet, bool val) { setBitValue(Enabled, val, inKeySet); }
++
++ bool isEnvMap(QSSGDataView<quint32> inKeySet) const { return getBitValue(EnvMap, inKeySet); }
++ void setEnvMap(QSSGDataRef<quint32> inKeySet, bool val) { setBitValue(EnvMap, val, inKeySet); }
++
++ bool isLightProbe(QSSGDataView<quint32> inKeySet) const { return getBitValue(LightProbe, inKeySet); }
++ void setLightProbe(QSSGDataRef<quint32> inKeySet, bool val) { setBitValue(LightProbe, val, inKeySet); }
++
++ bool isIdentityTransform(QSSGDataView<quint32> inKeySet) const { return getBitValue(Identity, inKeySet); }
++ void setIdentityTransform(QSSGDataRef<quint32> inKeySet, bool val) { setBitValue(Identity, val, inKeySet); }
++
++ bool isUsingUV1(QSSGDataView<quint32> inKeySet) const { return getBitValue(UsesUV1, inKeySet); }
++ void setUsesUV1(QSSGDataRef<quint32> inKeySet, bool val) { setBitValue(UsesUV1, val, inKeySet); }
++
++ bool isLinear(QSSGDataView<quint32> inKeySet) const { return getBitValue(Linear, inKeySet); }
++ void setLinear(QSSGDataRef<quint32> inKeySet, bool val) { setBitValue(Linear, val, inKeySet); }
++
++ bool isPreMultipliedAlpha(QSSGDataView<quint32> inKeySet) const { return getBitValue(PreMultipliedAlpha, inKeySet); }
++ void setPreMultipliedAlpha(QSSGDataRef<quint32> inKeySet, bool val) { setBitValue(PreMultipliedAlpha, val, inKeySet); }
++
++ void toString(QByteArray &ioStr, QSSGDataView<quint32> inKeySet) const
++ {
++ ioStr.append(name);
++ ioStr.append(QByteArrayView("={"));
++ internalToString(ioStr, QByteArrayView("enabled"), isEnabled(inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("envMap"), isEnvMap(inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("lightProbe"), isLightProbe(inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("identity"), isIdentityTransform(inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("usesUV1"), isUsingUV1(inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("linear"), isLinear(inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("preMultipliedAlpha"), isPreMultipliedAlpha(inKeySet));
++ ioStr.append('}');
++ }
++ };
++
++ struct QSSGShaderKeySpecularModel : QSSGShaderKeyUnsigned<2>
++ {
++ explicit QSSGShaderKeySpecularModel(const char *inName = "") : QSSGShaderKeyUnsigned<2>(inName) {}
++
++ void setSpecularModel(QSSGDataRef<quint32> inKeySet, QSSGRenderDefaultMaterial::MaterialSpecularModel inModel)
++ {
++ setValue(inKeySet, quint32(inModel));
++ }
++
++ QSSGRenderDefaultMaterial::MaterialSpecularModel getSpecularModel(QSSGDataView<quint32> inKeySet) const
++ {
++ return static_cast<QSSGRenderDefaultMaterial::MaterialSpecularModel>(getValue(inKeySet));
++ }
++
++ void toString(QByteArray &ioStr, QSSGDataView<quint32> inKeySet) const
++ {
++ ioStr.append(name);
++ ioStr.append('=');
++ switch (getSpecularModel(inKeySet)) {
++ case QSSGRenderDefaultMaterial::MaterialSpecularModel::SchlickGGX:
++ ioStr.append(QByteArrayView("SchlickGGX"));
++ break;
++ case QSSGRenderDefaultMaterial::MaterialSpecularModel::BlinnPhong:
++ ioStr.append(QByteArrayView("BlinnPhong"));
++ break;
++ }
++ }
++ void fromString(const QByteArray &ioStr, QSSGDataRef<quint32> inKeySet)
++ {
++ const qsizetype nameLen = name.size();
++ const int strOffset = ioStr.indexOf(name);
++ if (strOffset >= 0) {
++ /* The key is stored as name=specularMode; */
++ if (ioStr[strOffset + nameLen] != '=')
++ return;
++ const int codeOffsetBegin = strOffset + nameLen + 1;
++ int codeOffset = 0;
++ while (ioStr[codeOffsetBegin + codeOffset] != ';')
++ codeOffset++;
++ const QByteArray val = ioStr.mid(codeOffsetBegin, codeOffset);
++ if (val == QByteArrayView("SchlickGGX"))
++ setSpecularModel(inKeySet, QSSGRenderDefaultMaterial::MaterialSpecularModel::SchlickGGX);
++ if (val == QByteArrayView("BlinnPhong"))
++ setSpecularModel(inKeySet, QSSGRenderDefaultMaterial::MaterialSpecularModel::BlinnPhong);
++ }
++ }
++ };
++
++ struct QSSGShaderKeyDiffuseModel : QSSGShaderKeyUnsigned<2>
++ {
++ explicit QSSGShaderKeyDiffuseModel(const char *inName = "") : QSSGShaderKeyUnsigned<2>(inName) {}
++
++ void setDiffuseModel(QSSGDataRef<quint32> inKeySet, QSSGRenderDefaultMaterial::MaterialDiffuseModel inModel)
++ {
++ setValue(inKeySet, quint32(inModel));
++ }
++
++ QSSGRenderDefaultMaterial::MaterialDiffuseModel getDiffuseModel(QSSGDataView<quint32> inKeySet) const
++ {
++ return static_cast<QSSGRenderDefaultMaterial::MaterialDiffuseModel>(getValue(inKeySet));
++ }
++
++ void toString(QByteArray &ioStr, QSSGDataView<quint32> inKeySet) const
++ {
++ ioStr.append(name);
++ ioStr.append('=');
++ switch (getDiffuseModel(inKeySet)) {
++ case QSSGRenderDefaultMaterial::MaterialDiffuseModel::Burley:
++ ioStr.append(QByteArrayView("Burley"));
++ break;
++ case QSSGRenderDefaultMaterial::MaterialDiffuseModel::Lambert:
++ ioStr.append(QByteArrayView("Lambert"));
++ break;
++ case QSSGRenderDefaultMaterial::MaterialDiffuseModel::LambertWrap:
++ ioStr.append(QByteArrayView("LambertWrap"));
++ break;
++ }
++ }
++ void fromString(const QByteArray &ioStr, QSSGDataRef<quint32> inKeySet)
++ {
++ const qsizetype nameLen = name.size();
++ const int strOffset = ioStr.indexOf(name);
++ if (strOffset >= 0) {
++ /* The key is stored as name=specularMode; */
++ if (ioStr[strOffset + nameLen] != '=')
++ return;
++ const int codeOffsetBegin = strOffset + nameLen + 1;
++ int codeOffset = 0;
++ while (ioStr[codeOffsetBegin + codeOffset] != ';')
++ codeOffset++;
++ const QByteArray val = ioStr.mid(codeOffsetBegin, codeOffset);
++ if (val == QByteArrayView("Burley"))
++ setDiffuseModel(inKeySet, QSSGRenderDefaultMaterial::MaterialDiffuseModel::Burley);
++ if (val == QByteArrayView("Lambert"))
++ setDiffuseModel(inKeySet, QSSGRenderDefaultMaterial::MaterialDiffuseModel::Lambert);
++ if (val == QByteArrayView("LambertWrap"))
++ setDiffuseModel(inKeySet, QSSGRenderDefaultMaterial::MaterialDiffuseModel::LambertWrap);
++ }
++ }
++ };
++
++ struct QSSGShaderKeyShadowSoftness : QSSGShaderKeyUnsigned<2>
++ {
++ // possible values:
++ // SoftShadowQuality::Hard : 00
++ // SoftShadowQuality::PCF4 : 01
++ // SoftShadowQuality::PCF8 : 10
++ // SoftShadowQuality::PCF16 : 11
++ // All others map to PCF16
++
++ explicit QSSGShaderKeyShadowSoftness(const char *inName = "") : QSSGShaderKeyUnsigned<2>(inName) {}
++
++ void setShadowSoftness(QSSGDataRef<quint32> inKeySet, QSSGRenderLight::SoftShadowQuality inQuality)
++ {
++ quint32 val = 0;
++ switch (inQuality) {
++ case QSSGRenderLight::SoftShadowQuality::Hard:
++ val = 0;
++ break;
++ case QSSGRenderLight::SoftShadowQuality::PCF4:
++ val = 1;
++ break;
++ case QSSGRenderLight::SoftShadowQuality::PCF8:
++ val = 2;
++ break;
++ case QSSGRenderLight::SoftShadowQuality::PCF16:
++ default:
++ val = 3;
++ break;
++ }
++ setValue(inKeySet, val);
++ }
++
++ QSSGRenderLight::SoftShadowQuality getShadowSoftness(QSSGDataView<quint32> inKeySet) const
++ {
++ quint32 val = getValue(inKeySet);
++ switch (val) {
++ case 0:
++ return QSSGRenderLight::SoftShadowQuality::Hard;
++ case 1:
++ return QSSGRenderLight::SoftShadowQuality::PCF4;
++ case 2:
++ return QSSGRenderLight::SoftShadowQuality::PCF8;
++ case 3:
++ default:
++ return QSSGRenderLight::SoftShadowQuality::PCF16;
++ }
++ }
++
++ void toString(QByteArray &ioStr, QSSGDataView<quint32> inKeySet) const
++ {
++ ioStr.append(name);
++ ioStr.append('=');
++ switch (getShadowSoftness(inKeySet)) {
++ case QSSGRenderLight::SoftShadowQuality::Hard:
++ ioStr.append(QByteArrayView("Hard"));
++ break;
++ case QSSGRenderLight::SoftShadowQuality::PCF4:
++ ioStr.append(QByteArrayView("PCF4"));
++ break;
++ case QSSGRenderLight::SoftShadowQuality::PCF8:
++ ioStr.append(QByteArrayView("PCF8"));
++ break;
++ case QSSGRenderLight::SoftShadowQuality::PCF16:
++ case QSSGRenderLight::SoftShadowQuality::PCF32:
++ case QSSGRenderLight::SoftShadowQuality::PCF64:
++ ioStr.append(QByteArrayView("PCF16"));
++ break;
++ }
++ }
++
++ void fromString(const QByteArray &ioStr, QSSGDataRef<quint32> inKeySet)
++ {
++ const qsizetype nameLen = name.size();
++ const int strOffset = ioStr.indexOf(name);
++ if (strOffset >= 0) {
++ /* The key is stored as name=shadowSoftness; */
++ if (ioStr[strOffset + nameLen] != '=')
++ return;
++ const int codeOffsetBegin = strOffset + nameLen + 1;
++ int codeOffset = 0;
++ while (ioStr[codeOffsetBegin + codeOffset] != ';')
++ codeOffset++;
++ const QByteArray val = ioStr.mid(codeOffsetBegin, codeOffset);
++ if (val == QByteArrayView("Hard"))
++ setShadowSoftness(inKeySet, QSSGRenderLight::SoftShadowQuality::Hard);
++ if (val == QByteArrayView("PCF4"))
++ setShadowSoftness(inKeySet, QSSGRenderLight::SoftShadowQuality::PCF4);
++ if (val == QByteArrayView("PCF8"))
++ setShadowSoftness(inKeySet, QSSGRenderLight::SoftShadowQuality::PCF8);
++ if (val == QByteArrayView("PCF16"))
++ setShadowSoftness(inKeySet, QSSGRenderLight::SoftShadowQuality::PCF16);
++ }
++ }
++
++ };
++
++ struct QSSGShaderKeyAlphaMode : QSSGShaderKeyUnsigned<2>
++ {
++ explicit QSSGShaderKeyAlphaMode(const char *inName = "") : QSSGShaderKeyUnsigned<2>(inName) {}
++
++ void setAlphaMode(QSSGDataRef<quint32> inKeySet, QSSGRenderDefaultMaterial::MaterialAlphaMode inMode)
++ {
++ setValue(inKeySet, quint32(inMode));
++ }
++
++ QSSGRenderDefaultMaterial::MaterialAlphaMode getAlphaMode(QSSGDataView<quint32> inKeySet) const
++ {
++ return static_cast<QSSGRenderDefaultMaterial::MaterialAlphaMode>(getValue(inKeySet));
++ }
++
++ void toString(QByteArray &ioStr, QSSGDataView<quint32> inKeySet) const
++ {
++ ioStr.append(name);
++ ioStr.append('=');
++ switch (getAlphaMode(inKeySet)) {
++ case QSSGRenderDefaultMaterial::MaterialAlphaMode::Default:
++ ioStr.append(QByteArrayView("Default"));
++ break;
++ case QSSGRenderDefaultMaterial::MaterialAlphaMode::Mask:
++ ioStr.append(QByteArrayView("Mask"));
++ break;
++ case QSSGRenderDefaultMaterial::MaterialAlphaMode::Blend:
++ ioStr.append(QByteArrayView("Blend"));
++ break;
++ case QSSGRenderDefaultMaterial::MaterialAlphaMode::Opaque:
++ ioStr.append(QByteArrayView("Opaque"));
++ break;
++ }
++ }
++ void fromString(const QByteArray &ioStr, QSSGDataRef<quint32> inKeySet)
++ {
++ const qsizetype nameLen = name.size();
++ const qsizetype strOffset = ioStr.indexOf(name);
++ if (strOffset >= 0) {
++ /* The key is stored as name=alphaMode; */
++ if (ioStr[strOffset + nameLen] != '=')
++ return;
++ const int codeOffsetBegin = strOffset + nameLen + 1;
++ int codeOffset = 0;
++ while (ioStr[codeOffsetBegin + codeOffset] != ';')
++ codeOffset++;
++ const QByteArray val = ioStr.mid(codeOffsetBegin, codeOffset);
++ if (val == QByteArrayView("Default"))
++ setAlphaMode(inKeySet, QSSGRenderDefaultMaterial::MaterialAlphaMode::Default);
++ if (val == QByteArrayView("Mask"))
++ setAlphaMode(inKeySet, QSSGRenderDefaultMaterial::MaterialAlphaMode::Mask);
++ if (val == QByteArrayView("Blend"))
++ setAlphaMode(inKeySet, QSSGRenderDefaultMaterial::MaterialAlphaMode::Blend);
++ if (val == QByteArrayView("Opaque"))
++ setAlphaMode(inKeySet, QSSGRenderDefaultMaterial::MaterialAlphaMode::Opaque);
++ }
++ }
++ };
++
++ struct QSSGShaderKeyVertexAttribute : public QSSGShaderKeyUnsigned<9>
++ {
++ enum VertexAttributeBits {
++ Position = 1 << 0,
++ Normal = 1 << 1,
++ TexCoord0 = 1 << 2,
++ TexCoord1 = 1 << 3,
++ Tangent = 1 << 4,
++ Binormal = 1 << 5,
++ Color = 1 << 6,
++ JointAndWeight = 1 << 7,
++ TexCoordLightmap = 1 << 8
++ };
++
++ explicit QSSGShaderKeyVertexAttribute(const char *inName = "") : QSSGShaderKeyUnsigned<9>(inName) {}
++
++ bool getBitValue(VertexAttributeBits bit, QSSGDataView<quint32> inKeySet) const
++ {
++ return (getValue(inKeySet) & bit) ? true : false;
++ }
++ void setBitValue(VertexAttributeBits bit, QSSGDataRef<quint32> inKeySet, bool value) const
++ {
++ quint32 v = getValue(inKeySet);
++ v = value ? (v | bit) : (v & ~bit);
++ setValue(inKeySet, v);
++ }
++
++ void toString(QByteArray &ioStr, QSSGDataView<quint32> inKeySet) const
++ {
++ ioStr.append(name);
++ ioStr.append(QByteArrayView("={"));
++ internalToString(ioStr, QByteArrayView("position"), getBitValue(Position, inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("normal"), getBitValue(Normal, inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("texcoord0"), getBitValue(TexCoord0, inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("texcoord1"), getBitValue(TexCoord1, inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("tangent"), getBitValue(Tangent, inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("binormal"), getBitValue(Binormal, inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("color"), getBitValue(Color, inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("texcoordlightmap"), getBitValue(TexCoordLightmap, inKeySet));
++ ioStr.append(';');
++ internalToString(ioStr, QByteArrayView("joint&weight"), getBitValue(JointAndWeight, inKeySet));
++ ioStr.append('}');
++ }
++ void fromString(const QByteArray &ioStr, QSSGDataRef<quint32> inKeySet)
++ {
++ const qsizetype nameLen = name.size();
++ const qsizetype strOffset = ioStr.indexOf(name);
++ if (strOffset >= 0) {
++ /* The key is stored as name={;;;;;;} */
++ if (ioStr[strOffset + nameLen] != '=')
++ return;
++ if (ioStr[strOffset + nameLen + 1] != '{')
++ return;
++ const int codeOffsetBegin = strOffset + nameLen + 2;
++ int codeOffset = 0;
++ while (ioStr[codeOffsetBegin + codeOffset] != '}')
++ codeOffset++;
++ const QByteArray val = ioStr.mid(codeOffsetBegin, codeOffset);
++ const QVector<QByteArray> list = val.split(';');
++ if (list.size() != 8)
++ return;
++ setBitValue(Position, inKeySet, getBoolValue(list[0], QByteArrayView("position")));
++ setBitValue(Normal, inKeySet, getBoolValue(list[1], QByteArrayView("normal")));
++ setBitValue(TexCoord0, inKeySet, getBoolValue(list[2], QByteArrayView("texcoord0")));
++ setBitValue(TexCoord1, inKeySet, getBoolValue(list[3], QByteArrayView("texcoord1")));
++ setBitValue(Tangent, inKeySet, getBoolValue(list[4], QByteArrayView("tangent")));
++ setBitValue(Binormal, inKeySet, getBoolValue(list[5], QByteArrayView("binormal")));
++ setBitValue(Color, inKeySet, getBoolValue(list[6], QByteArrayView("color")));
++ setBitValue(TexCoordLightmap, inKeySet, getBoolValue(list[7], QByteArrayView("texcoordlightmap")));
++ }
++ }
++ };
++
++ struct QSSGShaderDefaultMaterialKeyProperties
++ {
++ enum {
++ SingleChannelImageCount = 16,
++ };
++ enum ImageMapNames {
++ DiffuseMap = 0,
++ BumpMap,
++ SpecularMap,
++ NormalMap,
++ ClearcoatNormalMap,
++ SheenColorMap,
++ AnisotropyMap,
++ // single channel images
++ OpacityMap,
++ RoughnessMap,
++ MetalnessMap,
++ OcclusionMap,
++ TranslucencyMap,
++ HeightMap,
++ ClearcoatMap,
++ ClearcoatRoughnessMap,
++ TransmissionMap,
++ ThicknessMap,
++ BaseColorMap,
++ SpecularAmountMap,
++ EmissiveMap,
++ SheenRoughnessMap,
++ IridescenceMap,
++ IridescenceThicknessMap,
++
++ ImageMapCount,
++ SingleChannelImagesFirst = OpacityMap
++ };
++ enum ImageChannelNames {
++ OpacityChannel = 0,
++ RoughnessChannel,
++ MetalnessChannel,
++ OcclusionChannel,
++ TranslucencyChannel,
++ HeightChannel,
++ ClearcoatChannel,
++ ClearcoatRoughnessChannel,
++ TransmissionChannel,
++ ThicknessChannel,
++ BaseColorChannel,
++ SpecularAmountChannel,
++ EmissiveChannel,
++ SheenRoughnessChannel,
++ IridescenceChannel,
++ IridescenceThicknessChannel,
++ };
++
++ QSSGShaderKeyBoolean m_hasLighting;
++ QSSGShaderKeyBoolean m_hasPunctualLights;
++ QSSGShaderKeyBoolean m_hasShadows;
++ QSSGShaderKeyBoolean m_hasIbl;
++ QSSGShaderKeyBoolean m_specularEnabled;
++ QSSGShaderKeyBoolean m_fresnelScaleBiasEnabled;
++ QSSGShaderKeyBoolean m_clearcoatFresnelScaleBiasEnabled;
++ QSSGShaderKeyBoolean m_fresnelEnabled;
++ QSSGShaderKeyBoolean m_baseColorSingleChannelEnabled;
++ QSSGShaderKeyBoolean m_specularSingleChannelEnabled;
++ QSSGShaderKeyBoolean m_emissiveSingleChannelEnabled;
++ QSSGShaderKeyBoolean m_invertOpacityMapValue;
++ QSSGShaderKeyBoolean m_vertexColorsEnabled;
++ QSSGShaderKeyBoolean m_vertexColorsMaskEnabled;
++ QSSGShaderKeyUnsigned<16> m_vertexColorRedMask;
++ QSSGShaderKeyUnsigned<16> m_vertexColorGreenMask;
++ QSSGShaderKeyUnsigned<16> m_vertexColorBlueMask;
++ QSSGShaderKeyUnsigned<16> m_vertexColorAlphaMask;
++ QSSGShaderKeySpecularModel m_specularModel;
++ QSSGShaderKeyDiffuseModel m_diffuseModel;
++ QSSGShaderKeyImageMap m_imageMaps[ImageMapCount];
++ QSSGShaderKeyTextureChannel m_textureChannels[SingleChannelImageCount];
++ QSSGShaderKeyUnsigned<16> m_boneCount;
++ QSSGShaderKeyBoolean m_isDoubleSided;
++ QSSGShaderKeyBoolean m_overridesPosition;
++ QSSGShaderKeyBoolean m_usesProjectionMatrix;
++ QSSGShaderKeyBoolean m_usesInverseProjectionMatrix;
++ QSSGShaderKeyBoolean m_usesPointsTopology;
++ QSSGShaderKeyBoolean m_usesVarColor;
++ QSSGShaderKeyAlphaMode m_alphaMode;
++ QSSGShaderKeyVertexAttribute m_vertexAttributes;
++ QSSGShaderKeyBoolean m_usesFloatJointIndices;
++ qsizetype m_stringBufferSizeHint = 0;
++ QSSGShaderKeyBoolean m_usesInstancing;
++ QSSGShaderKeyUnsigned<8> m_targetCount;
++ QSSGShaderKeyUnsigned<8> m_targetPositionOffset;
++ QSSGShaderKeyUnsigned<8> m_targetNormalOffset;
++ QSSGShaderKeyUnsigned<8> m_targetTangentOffset;
++ QSSGShaderKeyUnsigned<8> m_targetBinormalOffset;
++ QSSGShaderKeyUnsigned<8> m_targetTexCoord0Offset;
++ QSSGShaderKeyUnsigned<8> m_targetTexCoord1Offset;
++ QSSGShaderKeyUnsigned<8> m_targetColorOffset;
++ QSSGShaderKeyBoolean m_blendParticles;
++ QSSGShaderKeyBoolean m_clearcoatEnabled;
++ QSSGShaderKeyBoolean m_sheenEnabled;
++ QSSGShaderKeyBoolean m_anisotropyEnabled;
++ QSSGShaderKeyBoolean m_iridescenceEnabled;
++ QSSGShaderKeyBoolean m_dispersionEnabled;
++ QSSGShaderKeyBoolean m_transmissionEnabled;
++ QSSGShaderKeyBoolean m_specularAAEnabled;
++ QSSGShaderKeyBoolean m_lightmapEnabled;
++ QSSGShaderKeyBoolean m_specularGlossyEnabled;
++ QSSGShaderKeyBoolean m_metallicRoughnessEnabled;
++ QSSGShaderKeyUnsigned<4> m_debugMode;
++ QSSGShaderKeyBoolean m_fogEnabled;
++ QSSGShaderKeyUnsigned<3> m_viewCount;
++ QSSGShaderKeyBoolean m_usesViewIndex;
++ QSSGShaderKeyBoolean m_oitMSAA;
++ QSSGShaderKeyUnsigned<3> m_orderIndependentTransparency;
++ QSSGShaderKeyShadowSoftness m_shadowSoftness;
++
++ QSSGShaderDefaultMaterialKeyProperties()
++ : m_hasLighting("hasLighting")
++ , m_hasPunctualLights("hasPunctualLights")
++ , m_hasShadows("hasShadows")
++ , m_hasIbl("hasIbl")
++ , m_specularEnabled("specularEnabled")
++ , m_fresnelScaleBiasEnabled("fresnelScaleBiasEnabled")
++ , m_clearcoatFresnelScaleBiasEnabled("clearcoatFresnelScaleBiasEnabled")
++ , m_fresnelEnabled("fresnelEnabled")
++ , m_baseColorSingleChannelEnabled("baseColorSingleChannelEnabled")
++ , m_specularSingleChannelEnabled("specularSingleChannelEnabled")
++ , m_emissiveSingleChannelEnabled("emissiveSingleChannelEnabled")
++ , m_invertOpacityMapValue("invertOpacityMapValue")
++ , m_vertexColorsEnabled("vertexColorsEnabled")
++ , m_vertexColorsMaskEnabled("vertexColorsMaskEnabled")
++ , m_vertexColorRedMask("vertexColorRedMask")
++ , m_vertexColorGreenMask("vertexColorGreenMask")
++ , m_vertexColorBlueMask("vertexColorBlueMask")
++ , m_vertexColorAlphaMask("vertexColorAlphaMask")
++ , m_specularModel("specularModel")
++ , m_diffuseModel("diffuseModel")
++ , m_boneCount("boneCount")
++ , m_isDoubleSided("isDoubleSided")
++ , m_overridesPosition("overridesPosition")
++ , m_usesProjectionMatrix("usesProjectionMatrix")
++ , m_usesInverseProjectionMatrix("usesInverseProjectionMatrix")
++ , m_usesPointsTopology("usesPointsTopology")
++ , m_usesVarColor("usesVarColor")
++ , m_alphaMode("alphaMode")
++ , m_vertexAttributes("vertexAttributes")
++ , m_usesFloatJointIndices("usesFloatJointIndices")
++ , m_usesInstancing("usesInstancing")
++ , m_targetCount("targetCount")
++ , m_targetPositionOffset("targetPositionOffset")
++ , m_targetNormalOffset("targetNormalOffset")
++ , m_targetTangentOffset("targetTangentOffset")
++ , m_targetBinormalOffset("targetBinormalOffset")
++ , m_targetTexCoord0Offset("targetTexCoord0Offset")
++ , m_targetTexCoord1Offset("targetTexCoord1Offset")
++ , m_targetColorOffset("targetColorOffset")
++ , m_blendParticles("blendParticles")
++ , m_clearcoatEnabled("clearcoatEnabled")
++ , m_sheenEnabled("sheenEnabled")
++ , m_anisotropyEnabled("anisotropyEnabled")
++ , m_iridescenceEnabled("iridescenceEnabled")
++ , m_dispersionEnabled("dispersionEnabled")
++ , m_transmissionEnabled("transmissionEnabled")
++ , m_specularAAEnabled("specularAAEnabled")
++ , m_lightmapEnabled("lightmapEnabled")
++ , m_specularGlossyEnabled("specularGlossyEnabled")
++ , m_metallicRoughnessEnabled("metallicRoughnessEnabled")
++ , m_debugMode("debugMode")
++ , m_fogEnabled("fogEnabled")
++ , m_viewCount("viewCount")
++ , m_usesViewIndex("usesViewIndex")
++ , m_oitMSAA("oitMSAA")
++ , m_orderIndependentTransparency("orderIndependentTransparency")
++ , m_shadowSoftness("shadowSoftness")
++ {
++ m_imageMaps[DiffuseMap].name = "diffuseMap";
++ m_imageMaps[BumpMap].name = "bumpMap";
++ m_imageMaps[SpecularMap].name = "specularMap";
++ m_imageMaps[NormalMap].name = "normalMap";
++ m_imageMaps[ClearcoatNormalMap].name = "clearcoatNormalMap";
++ m_imageMaps[SheenColorMap].name = "sheenColorMap";
++ m_imageMaps[AnisotropyMap].name = "anisotropyMap";
++ m_imageMaps[OpacityMap].name = "opacityMap";
++ m_imageMaps[RoughnessMap].name = "roughnessMap";
++ m_imageMaps[MetalnessMap].name = "metalnessMap";
++ m_imageMaps[OcclusionMap].name = "occlusionMap";
++ m_imageMaps[TranslucencyMap].name = "translucencyMap";
++ m_imageMaps[HeightMap].name = "heightMap";
++ m_imageMaps[ClearcoatMap].name = "clearcoatMap";
++ m_imageMaps[ClearcoatRoughnessMap].name = "clearcoatRoughnessMap";
++ m_imageMaps[TransmissionMap].name = "transmissionMap";
++ m_imageMaps[ThicknessMap].name = "thicknessMap";
++ m_imageMaps[BaseColorMap].name = "baseColorMap";
++ m_imageMaps[SpecularAmountMap].name = "specularAmountMap";
++ m_imageMaps[EmissiveMap].name = "emissiveMap";
++ m_imageMaps[SheenRoughnessMap].name = "sheenRoughnessMap";
++ m_imageMaps[IridescenceMap].name = "iridescenceMap";
++ m_imageMaps[IridescenceThicknessMap].name = "iridescenceThicknessMap";
++
++ m_textureChannels[OpacityChannel].name = "opacityMap_channel";
++ m_textureChannels[RoughnessChannel].name = "roughnessMap_channel";
++ m_textureChannels[MetalnessChannel].name = "metalnessMap_channel";
++ m_textureChannels[OcclusionChannel].name = "occlusionMap_channel";
++ m_textureChannels[TranslucencyChannel].name = "translucencyMap_channel";
++ m_textureChannels[HeightChannel].name = "heightMap_channel";
++ m_textureChannels[ClearcoatChannel].name = "clearcoatMap_channel";
++ m_textureChannels[ClearcoatRoughnessChannel].name = "clearcoatRoughnessMap_channel";
++ m_textureChannels[TransmissionChannel].name = "transmissionMap_channel";
++ m_textureChannels[ThicknessChannel].name = "thicknessMap_channel";
++ m_textureChannels[BaseColorChannel].name = "baseColorMap_channel";
++ m_textureChannels[SpecularAmountChannel].name = "specularAmountMap_channel";
++ m_textureChannels[EmissiveChannel].name = "emissiveMap_channel";
++ m_textureChannels[SheenRoughnessChannel].name = "sheenRoughnessMap_channel";
++ m_textureChannels[IridescenceChannel].name = "iridescenceMap_channel";
++ m_textureChannels[IridescenceThicknessChannel].name = "iridescenceThicknessMap_channel";
++
++ init();
++ }
++
++ template<typename TVisitor>
++ void visitProperties(TVisitor &inVisitor)
++ {
++ inVisitor.visit(m_hasLighting);
++ inVisitor.visit(m_hasPunctualLights);
++ inVisitor.visit(m_hasShadows);
++ inVisitor.visit(m_hasIbl);
++ inVisitor.visit(m_specularEnabled);
++ inVisitor.visit(m_fresnelEnabled);
++ inVisitor.visit(m_fresnelScaleBiasEnabled);
++ inVisitor.visit(m_clearcoatFresnelScaleBiasEnabled);
++ inVisitor.visit(m_baseColorSingleChannelEnabled);
++ inVisitor.visit(m_specularSingleChannelEnabled);
++ inVisitor.visit(m_emissiveSingleChannelEnabled);
++ inVisitor.visit(m_invertOpacityMapValue);
++ inVisitor.visit(m_vertexColorsEnabled);
++ inVisitor.visit(m_vertexColorsMaskEnabled);
++ inVisitor.visit(m_vertexColorRedMask);
++ inVisitor.visit(m_vertexColorGreenMask);
++ inVisitor.visit(m_vertexColorBlueMask);
++ inVisitor.visit(m_vertexColorAlphaMask);
++ inVisitor.visit(m_specularModel);
++ inVisitor.visit(m_diffuseModel);
++
++ for (quint32 idx = 0, end = ImageMapCount; idx < end; ++idx)
++ inVisitor.visit(m_imageMaps[idx]);
++
++ for (auto &textureChannel : m_textureChannels)
++ inVisitor.visit(textureChannel);
++
++ inVisitor.visit(m_boneCount);
++ inVisitor.visit(m_isDoubleSided);
++ inVisitor.visit(m_overridesPosition);
++ inVisitor.visit(m_usesProjectionMatrix);
++ inVisitor.visit(m_usesInverseProjectionMatrix);
++ inVisitor.visit(m_usesPointsTopology);
++ inVisitor.visit(m_usesVarColor);
++ inVisitor.visit(m_alphaMode);
++ inVisitor.visit(m_vertexAttributes);
++ inVisitor.visit(m_usesFloatJointIndices);
++ inVisitor.visit(m_usesInstancing);
++ inVisitor.visit(m_targetCount);
++ inVisitor.visit(m_targetPositionOffset);
++ inVisitor.visit(m_targetNormalOffset);
++ inVisitor.visit(m_targetTangentOffset);
++ inVisitor.visit(m_targetBinormalOffset);
++ inVisitor.visit(m_targetTexCoord0Offset);
++ inVisitor.visit(m_targetTexCoord1Offset);
++ inVisitor.visit(m_targetColorOffset);
++ inVisitor.visit(m_blendParticles);
++ inVisitor.visit(m_clearcoatEnabled);
++ inVisitor.visit(m_sheenEnabled);
++ inVisitor.visit(m_anisotropyEnabled);
++ inVisitor.visit(m_iridescenceEnabled);
++ inVisitor.visit(m_dispersionEnabled);
++ inVisitor.visit(m_transmissionEnabled);
++ inVisitor.visit(m_specularAAEnabled);
++ inVisitor.visit(m_lightmapEnabled);
++ inVisitor.visit(m_specularGlossyEnabled);
++ inVisitor.visit(m_metallicRoughnessEnabled);
++ inVisitor.visit(m_debugMode);
++ inVisitor.visit(m_fogEnabled);
++ inVisitor.visit(m_viewCount);
++ inVisitor.visit(m_usesViewIndex);
++ inVisitor.visit(m_oitMSAA);
++ inVisitor.visit(m_orderIndependentTransparency);
++ inVisitor.visit(m_shadowSoftness);
++ }
++
++ struct OffsetVisitor
++ {
++ quint32 m_offset;
++ OffsetVisitor() : m_offset(0) {}
++ template<typename TPropType>
++ void visit(TPropType &inProp)
++ {
++ // if we cross the 32 bit border we just move
++ // to the next dword.
++ // This cost a few extra bits but prevents tedious errors like
++ // loosing shader key bits because they got moved beyond the 32 border
++ quint32 bit = m_offset % 32;
++ if (bit + TPropType::BitWidth > 32) {
++ m_offset += 32 - bit;
++ }
++
++ inProp.setOffset(m_offset);
++ m_offset += TPropType::BitWidth;
++ }
++ };
++
++ struct StringSizeVisitor
++ {
++ qsizetype size = 0;
++ template<typename P>
++ constexpr void visit(const P &prop)
++ {
++ size += prop.name.size();
++ }
++ };
++
++ struct InitVisitor
++ {
++ OffsetVisitor offsetVisitor;
++ StringSizeVisitor stringSizeVisitor;
++
++ template<typename P>
++ void visit(P &prop)
++ {
++ offsetVisitor.visit(prop);
++ stringSizeVisitor.visit(prop);
++ }
++ };
++
++ void init()
++ {
++ InitVisitor visitor;
++ visitProperties(visitor);
++
++ // If this assert fires, then the default material key needs more bits.
++ Q_ASSERT(visitor.offsetVisitor.m_offset < 800);
++ // This is so we can do some guestimate of how big the string buffer needs
++ // to be to avoid doing a lot of allocations when concatenating the strings.
++ m_stringBufferSizeHint = visitor.stringSizeVisitor.size;
++ }
++ };
++
++ template <typename Props, size_t size>
++ struct QSSGShaderBaseMaterialKey
++ {
++ enum {
++ DataBufferSize = size,
++ };
++ quint32 m_dataBuffer[DataBufferSize];
++ size_t m_featureSetHash;
++
++ explicit QSSGShaderBaseMaterialKey(size_t inFeatureSetHash) : m_featureSetHash(inFeatureSetHash)
++ {
++ for (size_t idx = 0; idx < DataBufferSize; ++idx)
++ m_dataBuffer[idx] = 0;
++ }
++
++ QSSGShaderBaseMaterialKey() : m_featureSetHash(0)
++ {
++ for (size_t idx = 0; idx < DataBufferSize; ++idx)
++ m_dataBuffer[idx] = 0;
++ }
++
++ size_t hash() const
++ {
++ size_t retval = 0;
++ for (size_t idx = 0; idx < DataBufferSize; ++idx)
++ retval = retval ^ qHash(m_dataBuffer[idx]);
++ return retval ^ m_featureSetHash;
++ }
++
++ bool operator==(const QSSGShaderBaseMaterialKey<Props, size> &other) const
++ {
++ bool retval = true;
++ for (size_t idx = 0; idx < DataBufferSize && retval; ++idx)
++ retval = m_dataBuffer[idx] == other.m_dataBuffer[idx];
++ return retval && m_featureSetHash == other.m_featureSetHash;
++ }
++
++ // Cast operators to make getting properties easier.
++ operator QSSGDataRef<quint32>() { return toDataRef(m_dataBuffer, DataBufferSize); }
++ operator QSSGDataView<quint32>() const { return toDataView(m_dataBuffer, DataBufferSize); }
++
++ struct StringVisitor
++ {
++ QByteArray &m_str;
++ QSSGDataView<quint32> m_keyStore;
++ StringVisitor(QByteArray &s, QSSGDataView<quint32> ks) : m_str(s), m_keyStore(ks) {}
++ template<typename TPropType>
++ void visit(const TPropType &prop)
++ {
++ const qsizetype originalSize = m_str.size();
++ if (m_str.size())
++ m_str.append(';');
++ prop.toString(m_str, m_keyStore);
++ // if the only thing we added was the semicolon
++ // then nuke the semicolon
++ if (originalSize && m_str.size() == (originalSize + 1))
++ m_str.resize(originalSize);
++ }
++ };
++
++ struct StringInVisitor
++ {
++ const QByteArray &m_str;
++ QSSGDataRef<quint32> m_keyStore;
++ StringInVisitor(const QByteArray &s, QSSGDataRef<quint32> ks) : m_str(s), m_keyStore(ks) {}
++
++ template<typename TPropType>
++ void visit(TPropType &prop)
++ {
++ prop.fromString(m_str, m_keyStore);
++ }
++ };
++
++ void toString(QByteArray &ioString, const Props &inProperties) const
++ {
++ ioString.reserve(inProperties.m_stringBufferSizeHint);
++ StringVisitor theVisitor(ioString, *this);
++ const_cast<Props &>(inProperties).visitProperties(theVisitor);
++ }
++ void fromString(QByteArray &ioString, Props &inProperties)
++ {
++ StringInVisitor theVisitor(ioString, *this);
++ inProperties.visitProperties(theVisitor);
++ }
++ QByteArray toByteArray() const
++ {
++ QByteArray ret;
++ ret.resize(sizeof(m_dataBuffer));
++ memcpy(ret.data(), m_dataBuffer, sizeof(m_dataBuffer));
++ return ret;
++ }
++ bool fromByteArray(const QByteArray &data) const
++ {
++ if (data.size() != sizeof(m_dataBuffer))
++ return false;
++ memcpy((void *)m_dataBuffer, data.data(), sizeof(m_dataBuffer));
++ return true;
++ }
++ };
++
++ typedef QSSGShaderBaseMaterialKey<QSSGShaderDefaultMaterialKeyProperties, 25> QSSGShaderDefaultMaterialKey;
++
++ Q_STATIC_ASSERT(std::is_trivially_destructible<QSSGShaderDefaultMaterialKey>::value);
++
++
++ inline size_t qHash(const QSSGShaderDefaultMaterialKey &key)
++ {
++ return key.hash();
++ }
++
++ QT_END_NAMESPACE
++
++ #endif