From cc74784d40052f610eb4128c693c3247fcb45990 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Wed, 9 Jun 2021 17:09:54 +0200 Subject: [PATCH] Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case. --- doc/changelog.dox | 3 + src/Magnum/Shaders/Phong.frag | 10 +++ src/Magnum/Shaders/Phong.h | 8 +-- src/Magnum/Shaders/PhongGL.cpp | 36 ++++++++--- src/Magnum/Shaders/PhongGL.h | 32 +++++++--- src/Magnum/Shaders/Test/CMakeLists.txt | 2 +- src/Magnum/Shaders/Test/PhongGLTest.cpp | 57 +++++++++++++++--- src/Magnum/Shaders/Test/PhongGL_Test.cpp | 4 +- ...specular.tga => shininess-no-specular.tga} | Bin .../Shaders/Test/ShadersGLBenchmark.cpp | 1 + 10 files changed, 119 insertions(+), 34 deletions(-) rename src/Magnum/Shaders/Test/PhongTestFiles/{shininess-black-specular.tga => shininess-no-specular.tga} (100%) diff --git a/doc/changelog.dox b/doc/changelog.dox index a805c3a9a..10e6d9f30 100644 --- a/doc/changelog.dox +++ b/doc/changelog.dox @@ -161,6 +161,9 @@ See also: @ref Trade::LightData - Added @ref Shaders::PhongGL::setLightSpecularColors() for better control over specular highlights +- Added @ref Shaders::PhongGL::Flag::NoSpecular as a significantly faster + alternative to setting specular color to @cpp 0x00000000_rgbaf @ce in case + specular highlights are not desired @subsubsection changelog-latest-new-shadertools ShaderTools library diff --git a/src/Magnum/Shaders/Phong.frag b/src/Magnum/Shaders/Phong.frag index fde89744a..1c21e5b0c 100644 --- a/src/Magnum/Shaders/Phong.frag +++ b/src/Magnum/Shaders/Phong.frag @@ -63,6 +63,7 @@ uniform lowp vec4 diffuseColor #endif ; +#ifndef NO_SPECULAR #ifdef EXPLICIT_UNIFORM_LOCATION layout(location = 7) #endif @@ -81,6 +82,7 @@ uniform mediump float shininess #endif ; #endif +#endif #ifdef NORMAL_TEXTURE #ifdef EXPLICIT_UNIFORM_LOCATION @@ -136,6 +138,7 @@ uniform lowp vec3 lightColors[LIGHT_COUNT] #endif ; +#ifndef NO_SPECULAR #ifdef EXPLICIT_UNIFORM_LOCATION layout(location = LIGHT_SPECULAR_COLORS_LOCATION) #endif @@ -144,6 +147,7 @@ uniform lowp vec3 lightSpecularColors[LIGHT_COUNT] = vec3[](LIGHT_COLOR_INITIALIZER) #endif ; +#endif #ifdef EXPLICIT_UNIFORM_LOCATION layout(location = LIGHT_RANGES_LOCATION) @@ -386,12 +390,14 @@ void main() { interpolatedVertexColor* #endif diffuseColor; + #ifndef NO_SPECULAR lowp const vec4 finalSpecularColor = #ifdef SPECULAR_TEXTURE texture(specularTexture, interpolatedTextureCoordinates)* #endif specularColor; #endif + #endif /* Ambient color */ fragmentColor = finalAmbientColor; @@ -439,6 +445,7 @@ void main() { i].light_color #endif ; + #ifndef NO_SPECULAR lowp const vec3 lightSpecularColor = #ifndef UNIFORM_BUFFERS lightSpecularColors[i] @@ -450,6 +457,7 @@ void main() { i].light_specularColor #endif ; + #endif lowp const float lightRange = #ifndef UNIFORM_BUFFERS lightRanges[i] @@ -490,6 +498,7 @@ void main() { lowp float intensity = max(0.0, dot(normalizedTransformedNormal, normalizedLightDirection))*attenuation; fragmentColor.rgb += finalDiffuseColor.rgb*lightColor*intensity; + #ifndef NO_SPECULAR /* Add specular color, if needed */ if(intensity > 0.001) { highp vec3 reflection = reflect(-normalizedLightDirection, normalizedTransformedNormal); @@ -497,6 +506,7 @@ void main() { mediump float specularity = clamp(pow(max(0.0, dot(cameraDirection, reflection)), shininess), 0.0, 1.0)*attenuation; fragmentColor += vec4(finalSpecularColor.rgb*lightSpecularColor.rgb*specularity, finalSpecularColor.a); } + #endif } fragmentColor.a += finalDiffuseColor.a; diff --git a/src/Magnum/Shaders/Phong.h b/src/Magnum/Shaders/Phong.h index 2e469f30e..b9b76ce93 100644 --- a/src/Magnum/Shaders/Phong.h +++ b/src/Magnum/Shaders/Phong.h @@ -326,8 +326,8 @@ struct PhongMaterialUniform { * * Default value is @cpp 0xffffff00_rgbaf @ce. * - * Used only if the effective light count for given draw is not zero, - * ignored otherwise. + * Used only if the effective light count for given draw is not zero and + * @ref PhongGL::Flag::NoSpecular is not set, ignored otherwise. * @see @ref PhongGL::setSpecularColor() */ Color4 specularColor; @@ -351,8 +351,8 @@ struct PhongMaterialUniform { * The larger value, the harder surface (smaller specular highlight). * Default value is @cpp 80.0f @ce. * - * Used only if the effective light count for given draw is not zero, - * ignored otherwise. + * Used only if the effective light count for given draw is not zero and + * @ref PhongGL::Flag::NoSpecular is not set, ignored otherwise. * @see @ref PhongGL::setShininess() */ Float shininess; diff --git a/src/Magnum/Shaders/PhongGL.cpp b/src/Magnum/Shaders/PhongGL.cpp index 12db5b999..57723011f 100644 --- a/src/Magnum/Shaders/PhongGL.cpp +++ b/src/Magnum/Shaders/PhongGL.cpp @@ -111,6 +111,9 @@ PhongGL::PhongGL(const Flags flags, const UnsignedInt lightCount "Shaders::PhongGL: light culling requires uniform buffers to be enabled", ); #endif + CORRADE_ASSERT(!(flags & Flag::SpecularTexture) || !(flags & (Flag::NoSpecular)), + "Shaders::PhongGL: specular texture requires the shader to not have specular disabled", ); + #ifndef MAGNUM_TARGET_GLES if(flags >= Flag::UniformBuffers) MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::ARB::uniform_buffer_object); @@ -243,6 +246,7 @@ PhongGL::PhongGL(const Flags flags, const UnsignedInt lightCount .addSource(flags & Flag::ObjectId ? "#define OBJECT_ID\n" : "") .addSource(flags >= Flag::InstancedObjectId ? "#define INSTANCED_OBJECT_ID\n" : "") #endif + .addSource(flags & Flag::NoSpecular ? "#define NO_SPECULAR\n" : "") ; #ifndef MAGNUM_TARGET_GLES2 if(flags >= Flag::UniformBuffers) { @@ -338,13 +342,16 @@ PhongGL::PhongGL(const Flags flags, const UnsignedInt lightCount if(lightCount) { _normalMatrixUniform = uniformLocation("normalMatrix"); _diffuseColorUniform = uniformLocation("diffuseColor"); - _specularColorUniform = uniformLocation("specularColor"); - _shininessUniform = uniformLocation("shininess"); + if(!(flags & Flag::NoSpecular)) { + _specularColorUniform = uniformLocation("specularColor"); + _shininessUniform = uniformLocation("shininess"); + } if(flags & Flag::NormalTexture) _normalTextureScaleUniform = uniformLocation("normalTextureScale"); _lightPositionsUniform = uniformLocation("lightPositions"); _lightColorsUniform = uniformLocation("lightColors"); - _lightSpecularColorsUniform = uniformLocation("lightSpecularColors"); + if(!(flags & Flag::NoSpecular)) + _lightSpecularColorsUniform = uniformLocation("lightSpecularColors"); _lightRangesUniform = uniformLocation("lightRanges"); } if(flags & Flag::AlphaMask) _alphaMaskUniform = uniformLocation("alphaMask"); @@ -393,14 +400,17 @@ PhongGL::PhongGL(const Flags flags, const UnsignedInt lightCount setProjectionMatrix(Matrix4{Math::IdentityInit}); if(lightCount) { setDiffuseColor(Magnum::Color4{1.0f}); - setSpecularColor(Magnum::Color4{1.0f, 0.0f}); - setShininess(80.0f); + if(!(flags & Flag::NoSpecular)) { + setSpecularColor(Magnum::Color4{1.0f, 0.0f}); + setShininess(80.0f); + } if(flags & Flag::NormalTexture) setNormalTextureScale(1.0f); setLightPositions(Containers::Array{DirectInit, lightCount, Vector4{0.0f, 0.0f, 1.0f, 0.0f}}); Containers::Array colors{DirectInit, lightCount, Magnum::Color3{1.0f}}; setLightColors(colors); - setLightSpecularColors(colors); + if(!(flags & Flag::NoSpecular)) + setLightSpecularColors(colors); setLightRanges(Containers::Array{DirectInit, lightCount, Constants::inf()}); /* Light position is zero by default */ setNormalMatrix(Matrix3x3{Math::IdentityInit}); @@ -441,6 +451,8 @@ PhongGL& PhongGL::setSpecularColor(const Magnum::Color4& color) { CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers), "Shaders::PhongGL::setSpecularColor(): the shader was created with uniform buffers enabled", *this); #endif + CORRADE_ASSERT(!(_flags >= Flag::NoSpecular), + "Shaders::PhongGL::setSpecularColor(): the shader was created with specular disabled", *this); if(_lightCount) setUniform(_specularColorUniform, color); return *this; } @@ -450,6 +462,8 @@ PhongGL& PhongGL::setShininess(Float shininess) { CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers), "Shaders::PhongGL::setShininess(): the shader was created with uniform buffers enabled", *this); #endif + CORRADE_ASSERT(!(_flags >= Flag::NoSpecular), + "Shaders::PhongGL::setShininess(): the shader was created with specular disabled", *this); if(_lightCount) setUniform(_shininessUniform, shininess); return *this; } @@ -651,6 +665,8 @@ PhongGL& PhongGL::setLightSpecularColors(const Containers::ArrayView= Flag::NoSpecular), + "Shaders::PhongGL::setLightSpecularColors(): the shader was created with specular disabled", *this); if(_lightCount) setUniform(_lightSpecularColorsUniform, colors); return *this; } @@ -666,6 +682,8 @@ PhongGL& PhongGL::setLightSpecularColor(const UnsignedInt id, const Magnum::Colo #endif CORRADE_ASSERT(id < _lightCount, "Shaders::PhongGL::setLightSpecularColor(): light ID" << id << "is out of bounds for" << _lightCount << "lights", *this); + CORRADE_ASSERT(!(_flags >= Flag::NoSpecular), + "Shaders::PhongGL::setLightSpecularColor(): the shader was created with specular disabled", *this); setUniform(_lightSpecularColorsUniform + id, color); return *this; } @@ -920,11 +938,12 @@ Debug& operator<<(Debug& debug, const PhongGL::Flag value) { _c(TextureArrays) _c(LightCulling) #endif + _c(NoSpecular) #undef _c /* LCOV_EXCL_STOP */ } - return debug << "(" << Debug::nospace << reinterpret_cast(UnsignedByte(value)) << Debug::nospace << ")"; + return debug << "(" << Debug::nospace << reinterpret_cast(UnsignedInt(value)) << Debug::nospace << ")"; } Debug& operator<<(Debug& debug, const PhongGL::Flags value) { @@ -947,8 +966,9 @@ Debug& operator<<(Debug& debug, const PhongGL::Flags value) { PhongGL::Flag::MultiDraw, /* Superset of UniformBuffers */ PhongGL::Flag::UniformBuffers, PhongGL::Flag::TextureArrays, - PhongGL::Flag::LightCulling + PhongGL::Flag::LightCulling, #endif + PhongGL::Flag::NoSpecular }); } diff --git a/src/Magnum/Shaders/PhongGL.h b/src/Magnum/Shaders/PhongGL.h index a585e12ea..5c1f014fe 100644 --- a/src/Magnum/Shaders/PhongGL.h +++ b/src/Magnum/Shaders/PhongGL.h @@ -484,7 +484,7 @@ class MAGNUM_SHADERS_EXPORT PhongGL: public GL::AbstractShaderProgram { * * @see @ref Flags, @ref flags() */ - enum class Flag: UnsignedShort { + enum class Flag: UnsignedInt { /** * Multiply ambient color with a texture. * @see @ref setAmbientColor(), @ref bindAmbientTexture() @@ -705,8 +705,17 @@ class MAGNUM_SHADERS_EXPORT PhongGL: public GL::AbstractShaderProgram { * 1.0. * @m_since_latest */ - LightCulling = 1 << 15 + LightCulling = 1 << 15, #endif + + /** + * Disable specular contribution in light calculation. Can result + * in a significant performance improvement compared to calling + * @ref setSpecularColor() with @cpp 0x00000000_rgbaf @ce when + * specular highlights are not desired. + * @m_since_latest + */ + NoSpecular = 1 << 16 }; /** @@ -900,10 +909,13 @@ class MAGNUM_SHADERS_EXPORT PhongGL: public GL::AbstractShaderProgram { * @brief Set specular color * @return Reference to self (for method chaining) * - * Initial value is @cpp 0xffffff00_rgbaf @ce. If + * Initial value is @cpp 0xffffff00_rgbaf @ce. Expects that the shader + * was not created with @ref Flag::NoSpecular. If * @ref Flag::SpecularTexture is set, the color will be multiplied with - * the texture. If you want to have a fully diffuse material, set - * the specular color to @cpp 0x00000000_rgbaf @ce. If + * the texture. If you want to have a fully diffuse material, it's + * recommended to disable the specular contribution altogether with + * @ref Flag::NoSpecular. If having a dedicated shader variant is not + * possible, set the specular color to @cpp 0x00000000_rgbaf @ce. If * @ref lightCount() is zero, this function is a no-op, as specular * color doesn't contribute to the output in that case. * @@ -1530,7 +1542,8 @@ class MAGNUM_SHADERS_EXPORT PhongGL: public GL::AbstractShaderProgram { * @return Reference to self (for method chaining) * * Expects that the shader was created with @ref Flag::SpecularTexture - * enabled. If @ref Flag::TextureArrays is enabled as well, use + * enabled and that @ref Flag::NoSpecular is not set. If + * @ref Flag::TextureArrays is enabled as well, use * @ref bindSpecularTexture(GL::Texture2DArray&) instead. If * @ref lightCount() is zero, this function is a no-op, as specular * color doesn't contribute to the output in that case. @@ -1545,9 +1558,10 @@ class MAGNUM_SHADERS_EXPORT PhongGL: public GL::AbstractShaderProgram { * @m_since_latest * * Expects that the shader was created with both - * @ref Flag::SpecularTexture and @ref Flag::TextureArrays enabled. If - * @ref Flag::UniformBuffers is not enabled, the layer is set via - * @ref setTextureLayer(); if @ref Flag::UniformBuffers is enabled, + * @ref Flag::SpecularTexture and @ref Flag::TextureArrays enabled and + * that @ref Flag::NoSpecular is not set. If @ref Flag::UniformBuffers + * is not enabled, the layer is set via @ref setTextureLayer(); if + * @ref Flag::UniformBuffers is enabled, * @ref Flag::TextureTransformation has to be enabled as well and the * layer is set via @ref TextureTransformationUniform::layer. If * @ref lightCount() is zero, this function is a no-op, as specular diff --git a/src/Magnum/Shaders/Test/CMakeLists.txt b/src/Magnum/Shaders/Test/CMakeLists.txt index 277a3da9f..021acb252 100644 --- a/src/Magnum/Shaders/Test/CMakeLists.txt +++ b/src/Magnum/Shaders/Test/CMakeLists.txt @@ -280,7 +280,7 @@ if(BUILD_GL_TESTS) PhongTestFiles/instanced.tga PhongTestFiles/instanced-normal.tga PhongTestFiles/low-light-angle.tga - PhongTestFiles/shininess-black-specular.tga + PhongTestFiles/shininess-no-specular.tga PhongTestFiles/shininess0-overflow.tga PhongTestFiles/shininess0.tga PhongTestFiles/shininess10.tga diff --git a/src/Magnum/Shaders/Test/PhongGLTest.cpp b/src/Magnum/Shaders/Test/PhongGLTest.cpp index 01f144f0a..9ab585b29 100644 --- a/src/Magnum/Shaders/Test/PhongGLTest.cpp +++ b/src/Magnum/Shaders/Test/PhongGLTest.cpp @@ -100,6 +100,7 @@ struct PhongGLTest: GL::OpenGLTester { void bindTextureArraysInvalid(); #endif void setAlphaMaskNotEnabled(); + void setSpecularDisabled(); void setTextureMatrixNotEnabled(); void setNormalTextureScaleNotEnabled(); #ifndef MAGNUM_TARGET_GLES2 @@ -233,6 +234,7 @@ constexpr struct { {"instanced object ID", PhongGL::Flag::InstancedObjectId, 1}, {"object ID + alpha mask + specular texture", PhongGL::Flag::ObjectId|PhongGL::Flag::AlphaMask|PhongGL::Flag::SpecularTexture, 1}, #endif + {"no specular", PhongGL::Flag::NoSpecular, 1}, {"five lights", {}, 5}, {"zero lights", {}, 0}, {"instanced transformation", PhongGL::Flag::InstancedTransformation, 3}, @@ -265,6 +267,7 @@ constexpr struct { {"normal texture + separate bitangents", PhongGL::Flag::UniformBuffers|PhongGL::Flag::NormalTexture|PhongGL::Flag::Bitangent, 1, 1, 1}, {"alpha mask", PhongGL::Flag::UniformBuffers|PhongGL::Flag::AlphaMask, 1, 1, 1}, {"object ID", PhongGL::Flag::UniformBuffers|PhongGL::Flag::ObjectId, 1, 1, 1}, + {"no specular", PhongGL::Flag::UniformBuffers|PhongGL::Flag::NoSpecular, 1, 1, 1}, {"multidraw with all the things", PhongGL::Flag::MultiDraw|PhongGL::Flag::TextureTransformation|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::AmbientTexture|PhongGL::Flag::SpecularTexture|PhongGL::Flag::NormalTexture|PhongGL::Flag::TextureArrays|PhongGL::Flag::AlphaMask|PhongGL::Flag::ObjectId|PhongGL::Flag::InstancedTextureOffset|PhongGL::Flag::InstancedTransformation|PhongGL::Flag::InstancedObjectId|PhongGL::Flag::LightCulling, 8, 16, 24} }; #endif @@ -284,6 +287,9 @@ constexpr struct { PhongGL::Flag::Bitangent|PhongGL::Flag::InstancedObjectId, "Bitangent attribute binding conflicts with the ObjectId attribute, use a Tangent4 attribute with instanced object ID rendering instead"}, #endif + {"specular texture but no specular", + PhongGL::Flag::SpecularTexture|PhongGL::Flag::NoSpecular, + "specular texture requires the shader to not have specular disabled"} }; #ifndef MAGNUM_TARGET_GLES2 @@ -472,14 +478,22 @@ const struct { const struct { const char* name; const char* expected; + PhongGL::Flags flags; Float shininess; Color4 specular; } RenderShininessData[] { - {"80", "shininess80.tga", 80.0f, 0xffffff_rgbf}, - {"10", "shininess10.tga", 10.0f, 0xffffff_rgbf}, - {"0", "shininess0.tga", 0.0f, 0xffffff_rgbf}, - {"0.001", "shininess0.tga", 0.001f, 0xffffff_rgbf}, - {"black specular", "shininess-black-specular.tga", 80.0f, 0x000000_rgbf} + {"80", "shininess80.tga", + {}, 80.0f, 0xffffff_rgbf}, + {"10", "shininess10.tga", + {}, 10.0f, 0xffffff_rgbf}, + {"0", "shininess0.tga", + {}, 0.0f, 0xffffff_rgbf}, + {"0.001", "shininess0.tga", + {}, 0.001f, 0xffffff_rgbf}, + {"black specular", "shininess-no-specular.tga", + {}, 80.0f, 0x000000_rgbf}, + {"no specular", "shininess-no-specular.tga", + PhongGL::Flag::NoSpecular, 80.0f, 0xffffff_rgbf} }; const struct { @@ -777,6 +791,7 @@ PhongGLTest::PhongGLTest() { addTests({ &PhongGLTest::setAlphaMaskNotEnabled, + &PhongGLTest::setSpecularDisabled, &PhongGLTest::setTextureMatrixNotEnabled, &PhongGLTest::setNormalTextureScaleNotEnabled, #ifndef MAGNUM_TARGET_GLES2 @@ -1306,6 +1321,27 @@ void PhongGLTest::setAlphaMaskNotEnabled() { "Shaders::PhongGL::setAlphaMask(): the shader was not created with alpha mask enabled\n"); } +void PhongGLTest::setSpecularDisabled() { + #ifdef CORRADE_NO_ASSERT + CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); + #endif + + std::ostringstream out; + Error redirectError{&out}; + + GL::Texture2D texture; + PhongGL shader{PhongGL::Flag::NoSpecular}; + shader.setSpecularColor({}) + .setShininess({}) + .setLightSpecularColors({{}}) + .setLightSpecularColor(0, {}); + CORRADE_COMPARE(out.str(), + "Shaders::PhongGL::setSpecularColor(): the shader was created with specular disabled\n" + "Shaders::PhongGL::setShininess(): the shader was created with specular disabled\n" + "Shaders::PhongGL::setLightSpecularColors(): the shader was created with specular disabled\n" + "Shaders::PhongGL::setLightSpecularColor(): the shader was created with specular disabled\n"); +} + void PhongGLTest::setTextureMatrixNotEnabled() { #ifdef CORRADE_NO_ASSERT CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions"); @@ -2427,13 +2463,14 @@ template void PhongGLTest::renderShininess() { GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32)); - PhongGL shader{flag}; + PhongGL shader{flag|data.flags}; if(flag == PhongGL::Flag{}) { + if(!(data.flags & PhongGL::Flag::NoSpecular)) shader + .setSpecularColor(data.specular) + .setShininess(data.shininess); shader .setLightPositions({{-3.0f, -3.0f, 2.0f, 0.0f}}) .setDiffuseColor(0xff3333_rgbf) - .setSpecularColor(data.specular) - .setShininess(data.shininess) .setTransformationMatrix(Matrix4::translation(Vector3::zAxis(-2.15f))) .setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)) .draw(sphere); @@ -2459,8 +2496,8 @@ template void PhongGLTest::renderShininess() { GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, { PhongMaterialUniform{} .setDiffuseColor(0xff3333_rgbf) - .setSpecularColor(data.specular) - .setShininess(data.shininess) + .setSpecularColor(data.specular) /* ignored if NoSpecular */ + .setShininess(data.shininess) /* ignored if NoSpecular */ }}; shader .bindProjectionBuffer(projectionUniform) diff --git a/src/Magnum/Shaders/Test/PhongGL_Test.cpp b/src/Magnum/Shaders/Test/PhongGL_Test.cpp index b00618d21..07f1f9ea9 100644 --- a/src/Magnum/Shaders/Test/PhongGL_Test.cpp +++ b/src/Magnum/Shaders/Test/PhongGL_Test.cpp @@ -72,8 +72,8 @@ void PhongGL_Test::constructCopy() { void PhongGL_Test::debugFlag() { std::ostringstream out; - Debug{&out} << PhongGL::Flag::AmbientTexture << PhongGL::Flag(0xf0); - CORRADE_COMPARE(out.str(), "Shaders::PhongGL::Flag::AmbientTexture Shaders::PhongGL::Flag(0xf0)\n"); + Debug{&out} << PhongGL::Flag::AmbientTexture << PhongGL::Flag(0xcafedead); + CORRADE_COMPARE(out.str(), "Shaders::PhongGL::Flag::AmbientTexture Shaders::PhongGL::Flag(0xcafedead)\n"); } void PhongGL_Test::debugFlags() { diff --git a/src/Magnum/Shaders/Test/PhongTestFiles/shininess-black-specular.tga b/src/Magnum/Shaders/Test/PhongTestFiles/shininess-no-specular.tga similarity index 100% rename from src/Magnum/Shaders/Test/PhongTestFiles/shininess-black-specular.tga rename to src/Magnum/Shaders/Test/PhongTestFiles/shininess-no-specular.tga diff --git a/src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp b/src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp index 6a716eefd..da0791c81 100644 --- a/src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp +++ b/src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp @@ -171,6 +171,7 @@ const struct { {"", {}, 1, 1, 1, false}, {"zero lights", {}, 0, 1, 1, false}, {"five lights", {}, 5, 1, 1, false}, + {"no specular", PhongGL::Flag::NoSpecular, 1, 1, 1, false}, {"vertex color", PhongGL::Flag::VertexColor, 1, 1, 1, false}, #ifndef MAGNUM_TARGET_GLES2 {"object ID", PhongGL::Flag::ObjectId, 1, 1, 1, false},