ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Trade: port away from deprecated MaterialData::tryAttribute().

pull/610/head
Vladimír Vondruš 4 years ago
parent
36f7e0c1d4
commit
b75cb7c584
7 changed files with 151 additions and 151 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      doc/snippets/MagnumTrade.cpp
  2. 16
      src/Magnum/Trade/FlatMaterialData.cpp
  3. 30
      src/Magnum/Trade/PbrClearCoatMaterialData.cpp
  4. 44
      src/Magnum/Trade/PbrMetallicRoughnessMaterialData.cpp
  5. 44
      src/Magnum/Trade/PbrSpecularGlossinessMaterialData.cpp
  6. 28
      src/Magnum/Trade/PhongMaterialData.cpp
  7. 138
      src/Magnum/Trade/Test/MaterialDataTest.cpp

2
doc/snippets/MagnumTrade.cpp
Unescape View File

@ -446,7 +446,7 @@ Float roughness = data.attribute<Float>(Trade::MaterialAttribute::Roughness);
Color4 color = data.attributeOr(Trade::MaterialAttribute::BaseColor,
0x3bd267ff_srgbaf);
if(Containers::Optional<UnsignedInt> texture =
data.tryAttribute<UnsignedInt>(Trade::MaterialAttribute::BaseColorTexture))
data.findAttribute<UnsignedInt>(Trade::MaterialAttribute::BaseColorTexture))
{
// ...
}

16
src/Magnum/Trade/FlatMaterialData.cpp
Unescape View File

@ -63,7 +63,7 @@ Color4 FlatMaterialData::color() const {
return attributeOr(MaterialAttribute::DiffuseColor, 0xffffffff_srgbaf);
/* If there's no texture, return whatever is present */
if(Containers::Optional<Color4> value = tryAttribute<Color4>(MaterialAttribute::BaseColor))
if(Containers::Optional<Color4> value = findAttribute<Color4>(MaterialAttribute::BaseColor))
return *value;
return attributeOr(MaterialAttribute::DiffuseColor, 0xffffffff_srgbaf);
}
@ -73,20 +73,20 @@ UnsignedInt FlatMaterialData::texture() const {
would be misleading as it can be also BaseColorTexture */
CORRADE_ASSERT(hasTexture(),
"Trade::FlatMaterialData::texture(): the material doesn't have a texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::BaseColorTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::BaseColorTexture))
return *value;
return attribute<UnsignedInt>(MaterialAttribute::DiffuseTexture);
}
Matrix3 FlatMaterialData::textureMatrix() const {
if(hasAttribute(MaterialAttribute::BaseColorTexture)) {
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::BaseColorTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::BaseColorTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
if(hasAttribute(MaterialAttribute::DiffuseTexture)) {
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::DiffuseTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::DiffuseTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -96,13 +96,13 @@ Matrix3 FlatMaterialData::textureMatrix() const {
UnsignedInt FlatMaterialData::textureCoordinates() const {
if(hasAttribute(MaterialAttribute::BaseColorTexture)) {
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::BaseColorTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::BaseColorTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
if(hasAttribute(MaterialAttribute::DiffuseTexture)) {
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -112,13 +112,13 @@ UnsignedInt FlatMaterialData::textureCoordinates() const {
UnsignedInt FlatMaterialData::textureLayer() const {
if(hasAttribute(MaterialAttribute::BaseColorTexture)) {
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::BaseColorTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::BaseColorTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
if(hasAttribute(MaterialAttribute::DiffuseTexture)) {
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}

30
src/Magnum/Trade/PbrClearCoatMaterialData.cpp
Unescape View File

@ -142,9 +142,9 @@ MaterialTextureSwizzle PbrClearCoatMaterialData::roughnessTextureSwizzle() const
Matrix3 PbrClearCoatMaterialData::roughnessTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::RoughnessTexture),
"Trade::PbrClearCoatMaterialData::roughnessTextureMatrix(): the layer doesn't have a roughness texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::RoughnessTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::RoughnessTextureMatrix))
return *value;
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::TextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::TextureMatrix))
return *value;
return attributeOr(0, MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -152,9 +152,9 @@ Matrix3 PbrClearCoatMaterialData::roughnessTextureMatrix() const {
UnsignedInt PbrClearCoatMaterialData::roughnessTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::RoughnessTexture),
"Trade::PbrClearCoatMaterialData::roughnessTextureCoordinates(): the layer doesn't have a roughness texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::RoughnessTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::RoughnessTextureCoordinates))
return *value;
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::TextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::TextureCoordinates))
return *value;
return attributeOr(0, MaterialAttribute::TextureCoordinates, 0u);
}
@ -162,9 +162,9 @@ UnsignedInt PbrClearCoatMaterialData::roughnessTextureCoordinates() const {
UnsignedInt PbrClearCoatMaterialData::roughnessTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::RoughnessTexture),
"Trade::PbrClearCoatMaterialData::roughnessTextureLayer(): the layer doesn't have a roughness texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::RoughnessTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::RoughnessTextureLayer))
return *value;
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::TextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::TextureLayer))
return *value;
return attributeOr(0, MaterialAttribute::TextureLayer, 0u);
}
@ -188,9 +188,9 @@ MaterialTextureSwizzle PbrClearCoatMaterialData::normalTextureSwizzle() const {
Matrix3 PbrClearCoatMaterialData::normalTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PbrClearCoatMaterialData::normalTextureMatrix(): the layer doesn't have a normal texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::NormalTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::NormalTextureMatrix))
return *value;
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::TextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::TextureMatrix))
return *value;
return attributeOr(0, MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -198,9 +198,9 @@ Matrix3 PbrClearCoatMaterialData::normalTextureMatrix() const {
UnsignedInt PbrClearCoatMaterialData::normalTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PbrClearCoatMaterialData::normalTextureCoordinates(): the layer doesn't have a normal texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::NormalTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::NormalTextureCoordinates))
return *value;
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::TextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::TextureCoordinates))
return *value;
return attributeOr(0, MaterialAttribute::TextureCoordinates, 0u);
}
@ -208,9 +208,9 @@ UnsignedInt PbrClearCoatMaterialData::normalTextureCoordinates() const {
UnsignedInt PbrClearCoatMaterialData::normalTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PbrClearCoatMaterialData::normalTextureLayer(): the layer doesn't have a normal texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::NormalTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::NormalTextureLayer))
return *value;
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::TextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::TextureLayer))
return *value;
return attributeOr(0, MaterialAttribute::TextureLayer, 0u);
}
@ -224,7 +224,7 @@ Matrix3 PbrClearCoatMaterialData::commonTextureMatrix() const {
return roughnessTextureMatrix();
if(hasAttribute(MaterialAttribute::NormalTexture))
return normalTextureMatrix();
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::TextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::TextureMatrix))
return *value;
return attributeOr(0, MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -238,7 +238,7 @@ UnsignedInt PbrClearCoatMaterialData::commonTextureCoordinates() const {
return roughnessTextureCoordinates();
if(hasAttribute(MaterialAttribute::NormalTexture))
return normalTextureCoordinates();
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::TextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::TextureCoordinates))
return *value;
return attributeOr(0, MaterialAttribute::TextureCoordinates, 0u);
}
@ -252,7 +252,7 @@ UnsignedInt PbrClearCoatMaterialData::commonTextureLayer() const {
return roughnessTextureLayer();
if(hasAttribute(MaterialAttribute::NormalTexture))
return normalTextureLayer();
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::TextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::TextureLayer))
return *value;
return attributeOr(0, MaterialAttribute::TextureLayer, 0u);
}

44
src/Magnum/Trade/PbrMetallicRoughnessMaterialData.cpp
Unescape View File

@ -251,7 +251,7 @@ UnsignedInt PbrMetallicRoughnessMaterialData::baseColorTexture() const {
Matrix3 PbrMetallicRoughnessMaterialData::baseColorTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::BaseColorTexture),
"Trade::PbrMetallicRoughnessMaterialData::baseColorTextureMatrix(): the material doesn't have a base color texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::BaseColorTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::BaseColorTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -259,7 +259,7 @@ Matrix3 PbrMetallicRoughnessMaterialData::baseColorTextureMatrix() const {
UnsignedInt PbrMetallicRoughnessMaterialData::baseColorTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::BaseColorTexture),
"Trade::PbrMetallicRoughnessMaterialData::baseColorTextureCoordinates(): the material doesn't have a base color texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::BaseColorTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::BaseColorTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -267,7 +267,7 @@ UnsignedInt PbrMetallicRoughnessMaterialData::baseColorTextureCoordinates() cons
UnsignedInt PbrMetallicRoughnessMaterialData::baseColorTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::BaseColorTexture),
"Trade::PbrMetallicRoughnessMaterialData::baseColorTextureLayer(): the material doesn't have a base color texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::BaseColorTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::BaseColorTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -277,9 +277,9 @@ Float PbrMetallicRoughnessMaterialData::metalness() const {
}
UnsignedInt PbrMetallicRoughnessMaterialData::metalnessTexture() const {
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::NoneRoughnessMetallicTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::NoneRoughnessMetallicTexture))
return *value;
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::MetalnessTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::MetalnessTexture))
return *value;
/* Explicit assertion because printing that MetalnessTexture isn't found
@ -298,7 +298,7 @@ MaterialTextureSwizzle PbrMetallicRoughnessMaterialData::metalnessTextureSwizzle
Matrix3 PbrMetallicRoughnessMaterialData::metalnessTextureMatrix() const {
CORRADE_ASSERT(hasMetalnessTexture(),
"Trade::PbrMetallicRoughnessMaterialData::metalnessTextureMatrix(): the material doesn't have a metalness texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::MetalnessTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::MetalnessTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -306,7 +306,7 @@ Matrix3 PbrMetallicRoughnessMaterialData::metalnessTextureMatrix() const {
UnsignedInt PbrMetallicRoughnessMaterialData::metalnessTextureCoordinates() const {
CORRADE_ASSERT(hasMetalnessTexture(),
"Trade::PbrMetallicRoughnessMaterialData::metalnessTextureCoordinates(): the material doesn't have a metalness texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::MetalnessTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::MetalnessTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -314,7 +314,7 @@ UnsignedInt PbrMetallicRoughnessMaterialData::metalnessTextureCoordinates() cons
UnsignedInt PbrMetallicRoughnessMaterialData::metalnessTextureLayer() const {
CORRADE_ASSERT(hasMetalnessTexture(),
"Trade::PbrMetallicRoughnessMaterialData::metalnessTextureLayer(): the material doesn't have a metalness texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::MetalnessTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::MetalnessTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -324,9 +324,9 @@ Float PbrMetallicRoughnessMaterialData::roughness() const {
}
UnsignedInt PbrMetallicRoughnessMaterialData::roughnessTexture() const {
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::NoneRoughnessMetallicTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::NoneRoughnessMetallicTexture))
return *value;
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::RoughnessTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::RoughnessTexture))
return *value;
/* Explicit assertion because printing that RoughnessTexture isn't found
@ -345,7 +345,7 @@ MaterialTextureSwizzle PbrMetallicRoughnessMaterialData::roughnessTextureSwizzle
Matrix3 PbrMetallicRoughnessMaterialData::roughnessTextureMatrix() const {
CORRADE_ASSERT(hasRoughnessTexture(),
"Trade::PbrMetallicRoughnessMaterialData::roughnessTextureMatrix(): the material doesn't have a roughness texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::RoughnessTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::RoughnessTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -353,7 +353,7 @@ Matrix3 PbrMetallicRoughnessMaterialData::roughnessTextureMatrix() const {
UnsignedInt PbrMetallicRoughnessMaterialData::roughnessTextureCoordinates() const {
CORRADE_ASSERT(hasRoughnessTexture(),
"Trade::PbrMetallicRoughnessMaterialData::roughnessTextureCoordinates(): the material doesn't have a roughness texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::RoughnessTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::RoughnessTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -361,7 +361,7 @@ UnsignedInt PbrMetallicRoughnessMaterialData::roughnessTextureCoordinates() cons
UnsignedInt PbrMetallicRoughnessMaterialData::roughnessTextureLayer() const {
CORRADE_ASSERT(hasRoughnessTexture(),
"Trade::PbrMetallicRoughnessMaterialData::roughnessTextureLayer(): the material doesn't have a roughness texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::RoughnessTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::RoughnessTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -385,7 +385,7 @@ MaterialTextureSwizzle PbrMetallicRoughnessMaterialData::normalTextureSwizzle()
Matrix3 PbrMetallicRoughnessMaterialData::normalTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PbrMetallicRoughnessMaterialData::normalTextureMatrix(): the material doesn't have a normal texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::NormalTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::NormalTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -393,7 +393,7 @@ Matrix3 PbrMetallicRoughnessMaterialData::normalTextureMatrix() const {
UnsignedInt PbrMetallicRoughnessMaterialData::normalTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PbrMetallicRoughnessMaterialData::normalTextureCoordinates(): the material doesn't have a normal texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::NormalTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::NormalTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -401,7 +401,7 @@ UnsignedInt PbrMetallicRoughnessMaterialData::normalTextureCoordinates() const {
UnsignedInt PbrMetallicRoughnessMaterialData::normalTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PbrMetallicRoughnessMaterialData::normalTextureLayer(): the material doesn't have a normal texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::NormalTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::NormalTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -425,7 +425,7 @@ MaterialTextureSwizzle PbrMetallicRoughnessMaterialData::occlusionTextureSwizzle
Matrix3 PbrMetallicRoughnessMaterialData::occlusionTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::OcclusionTexture),
"Trade::PbrMetallicRoughnessMaterialData::occlusionTextureMatrix(): the material doesn't have an occlusion texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::OcclusionTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::OcclusionTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -433,7 +433,7 @@ Matrix3 PbrMetallicRoughnessMaterialData::occlusionTextureMatrix() const {
UnsignedInt PbrMetallicRoughnessMaterialData::occlusionTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::OcclusionTexture),
"Trade::PbrMetallicRoughnessMaterialData::occlusionTextureCoordinates(): the material doesn't have an occlusion texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::OcclusionTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::OcclusionTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -441,7 +441,7 @@ UnsignedInt PbrMetallicRoughnessMaterialData::occlusionTextureCoordinates() cons
UnsignedInt PbrMetallicRoughnessMaterialData::occlusionTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::OcclusionTexture),
"Trade::PbrMetallicRoughnessMaterialData::occlusionTextureLayer(): the material doesn't have an occlusion texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::OcclusionTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::OcclusionTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -457,7 +457,7 @@ UnsignedInt PbrMetallicRoughnessMaterialData::emissiveTexture() const {
Matrix3 PbrMetallicRoughnessMaterialData::emissiveTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::EmissiveTexture),
"Trade::PbrMetallicRoughnessMaterialData::emissiveTextureMatrix(): the material doesn't have an emissive texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::EmissiveTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::EmissiveTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -465,7 +465,7 @@ Matrix3 PbrMetallicRoughnessMaterialData::emissiveTextureMatrix() const {
UnsignedInt PbrMetallicRoughnessMaterialData::emissiveTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::EmissiveTexture),
"Trade::PbrMetallicRoughnessMaterialData::emissiveTextureCoordinates(): the material doesn't have an emissive texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::EmissiveTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::EmissiveTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -473,7 +473,7 @@ UnsignedInt PbrMetallicRoughnessMaterialData::emissiveTextureCoordinates() const
UnsignedInt PbrMetallicRoughnessMaterialData::emissiveTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::EmissiveTexture),
"Trade::PbrMetallicRoughnessMaterialData::emissiveTextureLayer(): the material doesn't have an emissive texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::EmissiveTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::EmissiveTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}

44
src/Magnum/Trade/PbrSpecularGlossinessMaterialData.cpp
Unescape View File

@ -176,7 +176,7 @@ UnsignedInt PbrSpecularGlossinessMaterialData::diffuseTexture() const {
Matrix3 PbrSpecularGlossinessMaterialData::diffuseTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::DiffuseTexture),
"Trade::PbrSpecularGlossinessMaterialData::diffuseTextureMatrix(): the material doesn't have a diffuse texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::DiffuseTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::DiffuseTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -184,7 +184,7 @@ Matrix3 PbrSpecularGlossinessMaterialData::diffuseTextureMatrix() const {
UnsignedInt PbrSpecularGlossinessMaterialData::diffuseTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::DiffuseTexture),
"Trade::PbrSpecularGlossinessMaterialData::diffuseTextureCoordinates(): the material doesn't have a diffuse texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -192,7 +192,7 @@ UnsignedInt PbrSpecularGlossinessMaterialData::diffuseTextureCoordinates() const
UnsignedInt PbrSpecularGlossinessMaterialData::diffuseTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::DiffuseTexture),
"Trade::PbrSpecularGlossinessMaterialData::diffuseTextureLayer(): the material doesn't have a diffuse texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -202,9 +202,9 @@ Color4 PbrSpecularGlossinessMaterialData::specularColor() const {
}
UnsignedInt PbrSpecularGlossinessMaterialData::specularTexture() const {
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::SpecularGlossinessTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::SpecularGlossinessTexture))
return *value;
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::SpecularTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::SpecularTexture))
return *value;
/* Explicit assertion because printing that SpecularTexture isn't found
@ -223,7 +223,7 @@ MaterialTextureSwizzle PbrSpecularGlossinessMaterialData::specularTextureSwizzle
Matrix3 PbrSpecularGlossinessMaterialData::specularTextureMatrix() const {
CORRADE_ASSERT(hasSpecularTexture(),
"Trade::PbrSpecularGlossinessMaterialData::specularTextureMatrix(): the material doesn't have a specular texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::SpecularTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::SpecularTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -231,7 +231,7 @@ Matrix3 PbrSpecularGlossinessMaterialData::specularTextureMatrix() const {
UnsignedInt PbrSpecularGlossinessMaterialData::specularTextureCoordinates() const {
CORRADE_ASSERT(hasSpecularTexture(),
"Trade::PbrSpecularGlossinessMaterialData::specularTextureCoordinates(): the material doesn't have a specular texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::SpecularTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::SpecularTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -239,7 +239,7 @@ UnsignedInt PbrSpecularGlossinessMaterialData::specularTextureCoordinates() cons
UnsignedInt PbrSpecularGlossinessMaterialData::specularTextureLayer() const {
CORRADE_ASSERT(hasSpecularTexture(),
"Trade::PbrSpecularGlossinessMaterialData::specularTextureLayer(): the material doesn't have a specular texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::SpecularTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::SpecularTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -249,9 +249,9 @@ Float PbrSpecularGlossinessMaterialData::glossiness() const {
}
UnsignedInt PbrSpecularGlossinessMaterialData::glossinessTexture() const {
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::SpecularGlossinessTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::SpecularGlossinessTexture))
return *value;
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::GlossinessTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::GlossinessTexture))
return *value;
/* Explicit assertion because printing that GlossinessTexture isn't found
@ -270,7 +270,7 @@ MaterialTextureSwizzle PbrSpecularGlossinessMaterialData::glossinessTextureSwizz
Matrix3 PbrSpecularGlossinessMaterialData::glossinessTextureMatrix() const {
CORRADE_ASSERT(hasGlossinessTexture(),
"Trade::PbrSpecularGlossinessMaterialData::glossinessTextureMatrix(): the material doesn't have a glossiness texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::GlossinessTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::GlossinessTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -278,7 +278,7 @@ Matrix3 PbrSpecularGlossinessMaterialData::glossinessTextureMatrix() const {
UnsignedInt PbrSpecularGlossinessMaterialData::glossinessTextureCoordinates() const {
CORRADE_ASSERT(hasGlossinessTexture(),
"Trade::PbrSpecularGlossinessMaterialData::glossinessTextureCoordinates(): the material doesn't have a glossiness texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::GlossinessTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::GlossinessTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -286,7 +286,7 @@ UnsignedInt PbrSpecularGlossinessMaterialData::glossinessTextureCoordinates() co
UnsignedInt PbrSpecularGlossinessMaterialData::glossinessTextureLayer() const {
CORRADE_ASSERT(hasGlossinessTexture(),
"Trade::PbrSpecularGlossinessMaterialData::glossinessTextureLayer(): the material doesn't have a glossiness texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::GlossinessTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::GlossinessTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -310,7 +310,7 @@ MaterialTextureSwizzle PbrSpecularGlossinessMaterialData::normalTextureSwizzle()
Matrix3 PbrSpecularGlossinessMaterialData::normalTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PbrSpecularGlossinessMaterialData::normalTextureMatrix(): the material doesn't have a normal texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::NormalTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::NormalTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -318,7 +318,7 @@ Matrix3 PbrSpecularGlossinessMaterialData::normalTextureMatrix() const {
UnsignedInt PbrSpecularGlossinessMaterialData::normalTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PbrSpecularGlossinessMaterialData::normalTextureCoordinates(): the material doesn't have a normal texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::NormalTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::NormalTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -326,7 +326,7 @@ UnsignedInt PbrSpecularGlossinessMaterialData::normalTextureCoordinates() const
UnsignedInt PbrSpecularGlossinessMaterialData::normalTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PbrSpecularGlossinessMaterialData::normalTextureLayer(): the material doesn't have a normal texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::NormalTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::NormalTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -350,7 +350,7 @@ MaterialTextureSwizzle PbrSpecularGlossinessMaterialData::occlusionTextureSwizzl
Matrix3 PbrSpecularGlossinessMaterialData::occlusionTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::OcclusionTexture),
"Trade::PbrSpecularGlossinessMaterialData::occlusionTextureMatrix(): the material doesn't have an occlusion texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::OcclusionTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::OcclusionTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -358,7 +358,7 @@ Matrix3 PbrSpecularGlossinessMaterialData::occlusionTextureMatrix() const {
UnsignedInt PbrSpecularGlossinessMaterialData::occlusionTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::OcclusionTexture),
"Trade::PbrSpecularGlossinessMaterialData::occlusionTextureCoordinates(): the material doesn't have an occlusion texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::OcclusionTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::OcclusionTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -366,7 +366,7 @@ UnsignedInt PbrSpecularGlossinessMaterialData::occlusionTextureCoordinates() con
UnsignedInt PbrSpecularGlossinessMaterialData::occlusionTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::OcclusionTexture),
"Trade::PbrSpecularGlossinessMaterialData::occlusionTextureLayer(): the material doesn't have an occlusion texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::OcclusionTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::OcclusionTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -382,7 +382,7 @@ UnsignedInt PbrSpecularGlossinessMaterialData::emissiveTexture() const {
Matrix3 PbrSpecularGlossinessMaterialData::emissiveTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::EmissiveTexture),
"Trade::PbrSpecularGlossinessMaterialData::emissiveTextureMatrix(): the material doesn't have an emissive texture", {});
if(Containers::Optional<Matrix3> value = tryAttribute<Matrix3>(MaterialAttribute::EmissiveTextureMatrix))
if(Containers::Optional<Matrix3> value = findAttribute<Matrix3>(MaterialAttribute::EmissiveTextureMatrix))
return *value;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -390,7 +390,7 @@ Matrix3 PbrSpecularGlossinessMaterialData::emissiveTextureMatrix() const {
UnsignedInt PbrSpecularGlossinessMaterialData::emissiveTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::EmissiveTexture),
"Trade::PbrSpecularGlossinessMaterialData::emissiveTextureCoordinates(): the material doesn't have an emissive texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::EmissiveTextureCoordinates))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::EmissiveTextureCoordinates))
return *value;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -398,7 +398,7 @@ UnsignedInt PbrSpecularGlossinessMaterialData::emissiveTextureCoordinates() cons
UnsignedInt PbrSpecularGlossinessMaterialData::emissiveTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::EmissiveTexture),
"Trade::PbrSpecularGlossinessMaterialData::emissiveTextureLayer(): the material doesn't have an emissive texture", {});
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::EmissiveTextureLayer))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::EmissiveTextureLayer))
return *value;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}

28
src/Magnum/Trade/PhongMaterialData.cpp
Unescape View File

@ -239,7 +239,7 @@ UnsignedInt PhongMaterialData::ambientTexture() const {
Matrix3 PhongMaterialData::ambientTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::AmbientTexture),
"Trade::PhongMaterialData::ambientTextureMatrix(): the material doesn't have an ambient texture", {});
if(Containers::Optional<Matrix3> set = tryAttribute<Matrix3>(MaterialAttribute::AmbientTextureMatrix))
if(Containers::Optional<Matrix3> set = findAttribute<Matrix3>(MaterialAttribute::AmbientTextureMatrix))
return *set;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -247,7 +247,7 @@ Matrix3 PhongMaterialData::ambientTextureMatrix() const {
UnsignedInt PhongMaterialData::ambientTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::AmbientTexture),
"Trade::PhongMaterialData::ambientTextureCoordinates(): the material doesn't have an ambient texture", {});
if(Containers::Optional<UnsignedInt> set = tryAttribute<UnsignedInt>(MaterialAttribute::AmbientTextureCoordinates))
if(Containers::Optional<UnsignedInt> set = findAttribute<UnsignedInt>(MaterialAttribute::AmbientTextureCoordinates))
return *set;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -255,7 +255,7 @@ UnsignedInt PhongMaterialData::ambientTextureCoordinates() const {
UnsignedInt PhongMaterialData::ambientTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::AmbientTexture),
"Trade::PhongMaterialData::ambientTextureLayer(): the material doesn't have an ambient texture", {});
if(Containers::Optional<UnsignedInt> set = tryAttribute<UnsignedInt>(MaterialAttribute::AmbientTextureLayer))
if(Containers::Optional<UnsignedInt> set = findAttribute<UnsignedInt>(MaterialAttribute::AmbientTextureLayer))
return *set;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -271,7 +271,7 @@ UnsignedInt PhongMaterialData::diffuseTexture() const {
Matrix3 PhongMaterialData::diffuseTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::DiffuseTexture),
"Trade::PhongMaterialData::diffuseTextureMatrix(): the material doesn't have a diffuse texture", {});
if(Containers::Optional<Matrix3> set = tryAttribute<Matrix3>(MaterialAttribute::DiffuseTextureMatrix))
if(Containers::Optional<Matrix3> set = findAttribute<Matrix3>(MaterialAttribute::DiffuseTextureMatrix))
return *set;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -279,7 +279,7 @@ Matrix3 PhongMaterialData::diffuseTextureMatrix() const {
UnsignedInt PhongMaterialData::diffuseTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::DiffuseTexture),
"Trade::PhongMaterialData::diffuseTextureCoordinates(): the material doesn't have a diffuse texture", {});
if(Containers::Optional<UnsignedInt> set = tryAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureCoordinates))
if(Containers::Optional<UnsignedInt> set = findAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureCoordinates))
return *set;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -287,7 +287,7 @@ UnsignedInt PhongMaterialData::diffuseTextureCoordinates() const {
UnsignedInt PhongMaterialData::diffuseTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::DiffuseTexture),
"Trade::PhongMaterialData::diffuseTextureLayer(): the material doesn't have a diffuse texture", {});
if(Containers::Optional<UnsignedInt> set = tryAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureLayer))
if(Containers::Optional<UnsignedInt> set = findAttribute<UnsignedInt>(MaterialAttribute::DiffuseTextureLayer))
return *set;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -297,9 +297,9 @@ Color4 PhongMaterialData::specularColor() const {
}
UnsignedInt PhongMaterialData::specularTexture() const {
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::SpecularGlossinessTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::SpecularGlossinessTexture))
return *value;
if(Containers::Optional<UnsignedInt> value = tryAttribute<UnsignedInt>(MaterialAttribute::SpecularTexture))
if(Containers::Optional<UnsignedInt> value = findAttribute<UnsignedInt>(MaterialAttribute::SpecularTexture))
return *value;
/* Explicit assertion because printing that SpecularTexture isn't found
@ -318,7 +318,7 @@ MaterialTextureSwizzle PhongMaterialData::specularTextureSwizzle() const {
Matrix3 PhongMaterialData::specularTextureMatrix() const {
CORRADE_ASSERT(hasSpecularTexture(),
"Trade::PhongMaterialData::specularTextureMatrix(): the material doesn't have a specular texture", {});
if(Containers::Optional<Matrix3> set = tryAttribute<Matrix3>(MaterialAttribute::SpecularTextureMatrix))
if(Containers::Optional<Matrix3> set = findAttribute<Matrix3>(MaterialAttribute::SpecularTextureMatrix))
return *set;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -326,7 +326,7 @@ Matrix3 PhongMaterialData::specularTextureMatrix() const {
UnsignedInt PhongMaterialData::specularTextureCoordinates() const {
CORRADE_ASSERT(hasSpecularTexture(),
"Trade::PhongMaterialData::specularTextureCoordinates(): the material doesn't have a specular texture", {});
if(Containers::Optional<UnsignedInt> set = tryAttribute<UnsignedInt>(MaterialAttribute::SpecularTextureCoordinates))
if(Containers::Optional<UnsignedInt> set = findAttribute<UnsignedInt>(MaterialAttribute::SpecularTextureCoordinates))
return *set;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -334,7 +334,7 @@ UnsignedInt PhongMaterialData::specularTextureCoordinates() const {
UnsignedInt PhongMaterialData::specularTextureLayer() const {
CORRADE_ASSERT(hasSpecularTexture(),
"Trade::PhongMaterialData::specularTextureLayer(): the material doesn't have a specular texture", {});
if(Containers::Optional<UnsignedInt> set = tryAttribute<UnsignedInt>(MaterialAttribute::SpecularTextureLayer))
if(Containers::Optional<UnsignedInt> set = findAttribute<UnsignedInt>(MaterialAttribute::SpecularTextureLayer))
return *set;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}
@ -358,7 +358,7 @@ MaterialTextureSwizzle PhongMaterialData::normalTextureSwizzle() const {
Matrix3 PhongMaterialData::normalTextureMatrix() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PhongMaterialData::normalTextureMatrix(): the material doesn't have a normal texture", {});
if(Containers::Optional<Matrix3> set = tryAttribute<Matrix3>(MaterialAttribute::NormalTextureMatrix))
if(Containers::Optional<Matrix3> set = findAttribute<Matrix3>(MaterialAttribute::NormalTextureMatrix))
return *set;
return attributeOr(MaterialAttribute::TextureMatrix, Matrix3{});
}
@ -366,7 +366,7 @@ Matrix3 PhongMaterialData::normalTextureMatrix() const {
UnsignedInt PhongMaterialData::normalTextureCoordinates() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PhongMaterialData::normalTextureCoordinates(): the material doesn't have a normal texture", {});
if(Containers::Optional<UnsignedInt> set = tryAttribute<UnsignedInt>(MaterialAttribute::NormalTextureCoordinates))
if(Containers::Optional<UnsignedInt> set = findAttribute<UnsignedInt>(MaterialAttribute::NormalTextureCoordinates))
return *set;
return attributeOr(MaterialAttribute::TextureCoordinates, 0u);
}
@ -374,7 +374,7 @@ UnsignedInt PhongMaterialData::normalTextureCoordinates() const {
UnsignedInt PhongMaterialData::normalTextureLayer() const {
CORRADE_ASSERT(hasAttribute(MaterialAttribute::NormalTexture),
"Trade::PhongMaterialData::normalTextureLayer(): the material doesn't have a normal texture", {});
if(Containers::Optional<UnsignedInt> set = tryAttribute<UnsignedInt>(MaterialAttribute::NormalTextureLayer))
if(Containers::Optional<UnsignedInt> set = findAttribute<UnsignedInt>(MaterialAttribute::NormalTextureLayer))
return *set;
return attributeOr(MaterialAttribute::TextureLayer, 0u);
}

138
src/Magnum/Trade/Test/MaterialDataTest.cpp
Unescape View File

@ -1940,20 +1940,20 @@ void MaterialDataTest::accessOptional() {
}};
/* This exists */
CORRADE_VERIFY(data.tryAttribute("SpecularTexture"));
CORRADE_VERIFY(data.tryAttribute(MaterialAttribute::SpecularTexture));
CORRADE_COMPARE(*static_cast<const Int*>(data.tryAttribute("SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const Int*>(data.tryAttribute(MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>("SpecularTexture"), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(MaterialAttribute::SpecularTexture), 3);
CORRADE_VERIFY(data.findAttribute("SpecularTexture"));
CORRADE_VERIFY(data.findAttribute(MaterialAttribute::SpecularTexture));
CORRADE_COMPARE(*static_cast<const Int*>(data.findAttribute("SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const Int*>(data.findAttribute(MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>("SpecularTexture"), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>(MaterialAttribute::SpecularTexture), 3);
CORRADE_COMPARE(data.attributeOr("SpecularTexture", 5u), 3);
CORRADE_COMPARE(data.attributeOr(MaterialAttribute::SpecularTexture, 5u), 3);
/* This doesn't */
CORRADE_VERIFY(!data.tryAttribute("DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute(MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>("DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>(MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.findAttribute("DiffuseTexture"));
CORRADE_VERIFY(!data.findAttribute(MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.findAttribute<UnsignedInt>("DiffuseTexture"));
CORRADE_VERIFY(!data.findAttribute<UnsignedInt>(MaterialAttribute::DiffuseTexture));
CORRADE_COMPARE(data.attributeOr("DiffuseTexture", 5u), 5);
CORRADE_COMPARE(data.attributeOr(MaterialAttribute::DiffuseTexture, 5u), 5);
}
@ -2030,8 +2030,8 @@ void MaterialDataTest::accessWrongType() {
data.mutableAttribute<Color3>(0);
data.mutableAttribute<Color3>(MaterialAttribute::DiffuseColor);
data.mutableAttribute<Color3>("DiffuseColor");
data.tryAttribute<Color3>(MaterialAttribute::DiffuseColor);
data.tryAttribute<Color3>("DiffuseColor");
data.findAttribute<Color3>(MaterialAttribute::DiffuseColor);
data.findAttribute<Color3>("DiffuseColor");
data.attributeOr(MaterialAttribute::DiffuseColor, Color3{1.0f});
data.attributeOr("DiffuseColor", Color3{1.0f});
CORRADE_COMPARE(out.str(),
@ -2041,7 +2041,7 @@ void MaterialDataTest::accessWrongType() {
"Trade::MaterialData::mutableAttribute(): DiffuseColor is Trade::MaterialAttributeType::Vector4 but requested a type equivalent to Trade::MaterialAttributeType::Vector3\n"
"Trade::MaterialData::mutableAttribute(): DiffuseColor is Trade::MaterialAttributeType::Vector4 but requested a type equivalent to Trade::MaterialAttributeType::Vector3\n"
"Trade::MaterialData::mutableAttribute(): DiffuseColor is Trade::MaterialAttributeType::Vector4 but requested a type equivalent to Trade::MaterialAttributeType::Vector3\n"
/* tryAttribute() and attributeOr() delegate to attribute() so the
/* findAttribute() and attributeOr() delegate to attribute() so the
assert is the same */
"Trade::MaterialData::attribute(): DiffuseColor is Trade::MaterialAttributeType::Vector4 but requested a type equivalent to Trade::MaterialAttributeType::Vector3\n"
"Trade::MaterialData::attribute(): DiffuseColor is Trade::MaterialAttributeType::Vector4 but requested a type equivalent to Trade::MaterialAttributeType::Vector3\n"
@ -2098,8 +2098,8 @@ void MaterialDataTest::accessWrongTypeString() {
data.mutableAttribute<Containers::MutableStringView>(0);
data.mutableAttribute<Containers::MutableStringView>(MaterialAttribute::Shininess);
data.mutableAttribute<Containers::MutableStringView>("Shininess");
data.tryAttribute<Containers::StringView>(MaterialAttribute::Shininess);
data.tryAttribute<Containers::StringView>("Shininess");
data.findAttribute<Containers::StringView>(MaterialAttribute::Shininess);
data.findAttribute<Containers::StringView>("Shininess");
data.attributeOr(MaterialAttribute::Shininess, Containers::StringView{});
data.attributeOr("Shininess", Containers::StringView{});
CORRADE_COMPARE(out.str(),
@ -2109,7 +2109,7 @@ void MaterialDataTest::accessWrongTypeString() {
"Trade::MaterialData::mutableAttribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a string\n"
"Trade::MaterialData::mutableAttribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a string\n"
"Trade::MaterialData::mutableAttribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a string\n"
/* tryAttribute() and attributeOr() delegate to attribute() so the
/* findAttribute() and attributeOr() delegate to attribute() so the
assert is the same */
"Trade::MaterialData::attribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a string\n"
"Trade::MaterialData::attribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a string\n"
@ -2132,8 +2132,8 @@ void MaterialDataTest::accessWrongTypeBuffer() {
data.mutableAttribute<Containers::ArrayView<void>>(0);
data.mutableAttribute<Containers::ArrayView<void>>(MaterialAttribute::Shininess);
data.mutableAttribute<Containers::ArrayView<void>>("Shininess");
data.tryAttribute<Containers::ArrayView<const void>>(MaterialAttribute::Shininess);
data.tryAttribute<Containers::ArrayView<const void>>("Shininess");
data.findAttribute<Containers::ArrayView<const void>>(MaterialAttribute::Shininess);
data.findAttribute<Containers::ArrayView<const void>>("Shininess");
data.attributeOr(MaterialAttribute::Shininess, Containers::ArrayView<const void>{});
data.attributeOr("Shininess", Containers::ArrayView<const void>{});
CORRADE_COMPARE(out.str(),
@ -2143,7 +2143,7 @@ void MaterialDataTest::accessWrongTypeBuffer() {
"Trade::MaterialData::mutableAttribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a buffer\n"
"Trade::MaterialData::mutableAttribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a buffer\n"
"Trade::MaterialData::mutableAttribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a buffer\n"
/* tryAttribute() and attributeOr() delegate to attribute() so the
/* findAttribute() and attributeOr() delegate to attribute() so the
assert is the same */
"Trade::MaterialData::attribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a buffer\n"
"Trade::MaterialData::attribute(): Shininess of Trade::MaterialAttributeType::Float can't be retrieved as a buffer\n"
@ -2500,20 +2500,20 @@ void MaterialDataTest::accessLayerIndexOptional() {
}, {1, 3}};
/* This exists */
CORRADE_VERIFY(data.tryAttribute(1, "SpecularTexture"));
CORRADE_VERIFY(data.tryAttribute(1, MaterialAttribute::SpecularTexture));
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute(1, "SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute(1, MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(1, "SpecularTexture"), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(1, MaterialAttribute::SpecularTexture), 3);
CORRADE_VERIFY(data.findAttribute(1, "SpecularTexture"));
CORRADE_VERIFY(data.findAttribute(1, MaterialAttribute::SpecularTexture));
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.findAttribute(1, "SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.findAttribute(1, MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>(1, "SpecularTexture"), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>(1, MaterialAttribute::SpecularTexture), 3);
CORRADE_COMPARE(data.attributeOr(1, "SpecularTexture", 5u), 3);
CORRADE_COMPARE(data.attributeOr(1, MaterialAttribute::SpecularTexture, 5u), 3);
/* This doesn't */
CORRADE_VERIFY(!data.tryAttribute(1, "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute(1, MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>(1, "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>(1, MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.findAttribute(1, "DiffuseTexture"));
CORRADE_VERIFY(!data.findAttribute(1, MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.findAttribute<UnsignedInt>(1, "DiffuseTexture"));
CORRADE_VERIFY(!data.findAttribute<UnsignedInt>(1, MaterialAttribute::DiffuseTexture));
CORRADE_COMPARE(data.attributeOr(1, "DiffuseTexture", 5u), 5);
CORRADE_COMPARE(data.attributeOr(1, MaterialAttribute::DiffuseTexture, 5u), 5);
}
@ -2527,20 +2527,20 @@ void MaterialDataTest::accessLayerNameOptional() {
}, {1, 4}};
/* This exists */
CORRADE_VERIFY(data.tryAttribute(MaterialLayer::ClearCoat, "SpecularTexture"));
CORRADE_VERIFY(data.tryAttribute(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture));
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute(MaterialLayer::ClearCoat, "SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(MaterialLayer::ClearCoat, "SpecularTexture"), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture), 3);
CORRADE_VERIFY(data.findAttribute(MaterialLayer::ClearCoat, "SpecularTexture"));
CORRADE_VERIFY(data.findAttribute(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture));
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.findAttribute(MaterialLayer::ClearCoat, "SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.findAttribute(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>(MaterialLayer::ClearCoat, "SpecularTexture"), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture), 3);
CORRADE_COMPARE(data.attributeOr(MaterialLayer::ClearCoat, "SpecularTexture", 5u), 3);
CORRADE_COMPARE(data.attributeOr(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture, 5u), 3);
/* This doesn't */
CORRADE_VERIFY(!data.tryAttribute(MaterialLayer::ClearCoat, "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute(MaterialLayer::ClearCoat, MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>(MaterialLayer::ClearCoat, "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>(MaterialLayer::ClearCoat, MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.findAttribute(MaterialLayer::ClearCoat, "DiffuseTexture"));
CORRADE_VERIFY(!data.findAttribute(MaterialLayer::ClearCoat, MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.findAttribute<UnsignedInt>(MaterialLayer::ClearCoat, "DiffuseTexture"));
CORRADE_VERIFY(!data.findAttribute<UnsignedInt>(MaterialLayer::ClearCoat, MaterialAttribute::DiffuseTexture));
CORRADE_COMPARE(data.attributeOr(MaterialLayer::ClearCoat, "DiffuseTexture", 5u), 5);
CORRADE_COMPARE(data.attributeOr(MaterialLayer::ClearCoat, MaterialAttribute::DiffuseTexture, 5u), 5);
}
@ -2554,20 +2554,20 @@ void MaterialDataTest::accessLayerStringOptional() {
}, {1, 4}};
/* This exists */
CORRADE_VERIFY(data.tryAttribute("ClearCoat", "SpecularTexture"));
CORRADE_VERIFY(data.tryAttribute("ClearCoat", MaterialAttribute::SpecularTexture));
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute("ClearCoat", "SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute("ClearCoat", MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>("ClearCoat", "SpecularTexture"), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>("ClearCoat", MaterialAttribute::SpecularTexture), 3);
CORRADE_VERIFY(data.findAttribute("ClearCoat", "SpecularTexture"));
CORRADE_VERIFY(data.findAttribute("ClearCoat", MaterialAttribute::SpecularTexture));
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.findAttribute("ClearCoat", "SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.findAttribute("ClearCoat", MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>("ClearCoat", "SpecularTexture"), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>("ClearCoat", MaterialAttribute::SpecularTexture), 3);
CORRADE_COMPARE(data.attributeOr("ClearCoat", "SpecularTexture", 5u), 3);
CORRADE_COMPARE(data.attributeOr("ClearCoat", MaterialAttribute::SpecularTexture, 5u), 3);
/* This doesn't */
CORRADE_VERIFY(!data.tryAttribute("ClearCoat", "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute("ClearCoat", MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>("ClearCoat", "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>("ClearCoat", MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.findAttribute("ClearCoat", "DiffuseTexture"));
CORRADE_VERIFY(!data.findAttribute("ClearCoat", MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.findAttribute<UnsignedInt>("ClearCoat", "DiffuseTexture"));
CORRADE_VERIFY(!data.findAttribute<UnsignedInt>("ClearCoat", MaterialAttribute::DiffuseTexture));
CORRADE_COMPARE(data.attributeOr("ClearCoat", "DiffuseTexture", 5u), 5);
CORRADE_COMPARE(data.attributeOr("ClearCoat", MaterialAttribute::DiffuseTexture, 5u), 5);
}
@ -2615,10 +2615,10 @@ void MaterialDataTest::accessLayerOutOfBounds() {
data.mutableAttribute<Int>(2, "AlphaMask");
data.mutableAttribute<Int>(2, MaterialAttribute::AlphaMask);
data.mutableAttribute<Containers::MutableStringView>(2, 0);
data.tryAttribute(2, "AlphaMask");
data.tryAttribute(2, MaterialAttribute::AlphaMask);
data.tryAttribute<bool>(2, "AlphaMask");
data.tryAttribute<bool>(2, MaterialAttribute::AlphaMask);
data.findAttribute(2, "AlphaMask");
data.findAttribute(2, MaterialAttribute::AlphaMask);
data.findAttribute<bool>(2, "AlphaMask");
data.findAttribute<bool>(2, MaterialAttribute::AlphaMask);
data.attributeOr(2, "AlphaMask", false);
data.attributeOr(2, MaterialAttribute::AlphaMask, false);
CORRADE_COMPARE(out.str(),
@ -2708,10 +2708,10 @@ void MaterialDataTest::accessLayerNotFound() {
data.mutableAttribute<Int>("ClearCoat", "AlphaMask");
data.mutableAttribute<Int>("ClearCoat", MaterialAttribute::AlphaMask);
data.mutableAttribute<Containers::MutableStringView>("ClearCoat", 0);
data.tryAttribute("ClearCoat", "AlphaMask");
data.tryAttribute("ClearCoat", MaterialAttribute::AlphaMask);
data.tryAttribute<bool>("ClearCoat", "AlphaMask");
data.tryAttribute<bool>("ClearCoat", MaterialAttribute::AlphaMask);
data.findAttribute("ClearCoat", "AlphaMask");
data.findAttribute("ClearCoat", MaterialAttribute::AlphaMask);
data.findAttribute<bool>("ClearCoat", "AlphaMask");
data.findAttribute<bool>("ClearCoat", MaterialAttribute::AlphaMask);
data.attributeOr("ClearCoat", "AlphaMask", false);
data.attributeOr("ClearCoat", MaterialAttribute::AlphaMask, false);
CORRADE_COMPARE(out.str(),
@ -2796,10 +2796,10 @@ void MaterialDataTest::accessInvalidLayerName() {
data.mutableAttribute<Int>(MaterialLayer(0xfefe), "AlphaMask");
data.mutableAttribute<Int>(MaterialLayer(0xfefe), MaterialAttribute::AlphaMask);
data.mutableAttribute<Containers::MutableStringView>(MaterialLayer(0xfefe), 0);
data.tryAttribute(MaterialLayer(0xfefe), "AlphaMask");
data.tryAttribute(MaterialLayer(0xfefe), MaterialAttribute::AlphaMask);
data.tryAttribute<bool>(MaterialLayer(0xfefe), "AlphaMask");
data.tryAttribute<bool>(MaterialLayer(0xfefe), MaterialAttribute::AlphaMask);
data.findAttribute(MaterialLayer(0xfefe), "AlphaMask");
data.findAttribute(MaterialLayer(0xfefe), MaterialAttribute::AlphaMask);
data.findAttribute<bool>(MaterialLayer(0xfefe), "AlphaMask");
data.findAttribute<bool>(MaterialLayer(0xfefe), MaterialAttribute::AlphaMask);
data.attributeOr(MaterialLayer(0xfefe), "AlphaMask", false);
data.attributeOr(MaterialLayer(0xfefe), MaterialAttribute::AlphaMask, false);
CORRADE_COMPARE(out.str(),
@ -2988,10 +2988,10 @@ void MaterialDataTest::accessInvalidAttributeName() {
data.mutableAttribute("Layer", MaterialAttribute(0xfefe));
data.mutableAttribute<Int>(0, MaterialAttribute(0x0));
data.mutableAttribute<Int>("Layer", MaterialAttribute(0xfefe));
data.tryAttribute(0, MaterialAttribute(0x0));
data.tryAttribute("Layer", MaterialAttribute(0xfefe));
data.tryAttribute<Int>(0, MaterialAttribute(0x0));
data.tryAttribute<Int>("Layer", MaterialAttribute(0xfefe));
data.findAttribute(0, MaterialAttribute(0x0));
data.findAttribute("Layer", MaterialAttribute(0xfefe));
data.findAttribute<Int>(0, MaterialAttribute(0x0));
data.findAttribute<Int>("Layer", MaterialAttribute(0xfefe));
data.attributeOr(0, MaterialAttribute(0x0), 42);
data.attributeOr("Layer", MaterialAttribute(0xfefe), 42);
CORRADE_COMPARE(out.str(),
@ -3220,11 +3220,11 @@ void MaterialDataTest::templateLayerAccess() {
CORRADE_COMPARE(data.mutableAttribute<UnsignedInt>(MaterialAttribute::LayerFactorTexture), 3);
CORRADE_COMPARE(data.mutableAttribute<UnsignedInt>("LayerFactorTexture"), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute(MaterialAttribute::LayerFactorTexture)), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute("LayerFactorTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.findAttribute(MaterialAttribute::LayerFactorTexture)), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.findAttribute("LayerFactorTexture")), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(MaterialAttribute::LayerFactorTexture), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>("LayerFactorTexture"), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>(MaterialAttribute::LayerFactorTexture), 3);
CORRADE_COMPARE(data.findAttribute<UnsignedInt>("LayerFactorTexture"), 3);
CORRADE_COMPARE(data.attributeOr(MaterialAttribute::LayerFactorTexture, 5u), 3);
CORRADE_COMPARE(data.attributeOr("LayerFactorTexture", 5u), 3);

Write Preview
Loading…
Cancel
Save