Shaders: debug output for all Flag / Flags enums / enum sets.

doc/changelog.dox

@@ -140,6 +140,10 @@ See also:
     distinction between three- and four-component vertex color attribute.
 -   Classical alpha masking support in @ref Shaders::Flat and
     @ref Shaders::Phong
+-   Debug output for the @ref Shaders::Flat::Flag / @ref Shaders::Flat::Flags,
+    @ref Shaders::MeshVisualizer::Flag / @ref Shaders::MeshVisualizer::Flags
+    and @ref Shaders::Phong::Flag / @ref Shaders::Phong::Flags enums / enum
+    sets
 
 @subsubsection changelog-latest-new-trade Trade library
 

src/Magnum/Shaders/Flat.cpp

@@ -25,6 +25,7 @@
 
 #include "Flat.h"
 
+#include <Corrade/Containers/EnumSet.hpp>
 #include <Corrade/Utility/Resource.h>
 
 #include "Magnum/GL/Context.h"
@@ -125,4 +126,27 @@ template<UnsignedInt dimensions> Flat<dimensions>& Flat<dimensions>::setAlphaMas
 template class Flat<2>;
 template class Flat<3>;
 
+namespace Implementation {
+
+Debug& operator<<(Debug& debug, const FlatFlag value) {
+    switch(value) {
+        /* LCOV_EXCL_START */
+        #define _c(v) case FlatFlag::v: return debug << "Shaders::Flat::Flag::" #v;
+        _c(Textured)
+        _c(AlphaMask)
+        #undef _c
+        /* LCOV_EXCL_STOP */
+    }
+
+    return debug << "Shaders::Flat::Flag(" << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(value)) << Debug::nospace << ")";
+}
+
+Debug& operator<<(Debug& debug, const FlatFlags value) {
+    return Containers::enumSetDebugOutput(debug, value, "Shaders::Flat::Flags{}", {
+        FlatFlag::Textured,
+        FlatFlag::AlphaMask});
+}
+
+}
+
 }}

src/Magnum/Shaders/Flat.h

@@ -259,7 +259,20 @@ typedef Flat<2> Flat2D;
 /** @brief 3D flat shader */
 typedef Flat<3> Flat3D;
 
-CORRADE_ENUMSET_OPERATORS(Implementation::FlatFlags)
+#ifdef DOXYGEN_GENERATING_OUTPUT
+/** @debugoperatorclassenum{Flat,Flat::Flag} */
+template<UnsignedInt dimensions> Debug& operator<<(Debug& debug, Flat<dimensions>::Flag value);
+
+/** @debugoperatorclassenum{Flat,Flat::Flags} */
+template<UnsignedInt dimensions> Debug& operator<<(Debug& debug, Flat<dimensions>::Flags value);
+#else
+namespace Implementation {
+    MAGNUM_SHADERS_EXPORT Debug& operator<<(Debug& debug, FlatFlag value);
+    MAGNUM_SHADERS_EXPORT Debug& operator<<(Debug& debug, FlatFlags value);
+    CORRADE_ENUMSET_OPERATORS(FlatFlags)
+}
+#endif
+
 
 }}
 

src/Magnum/Shaders/MeshVisualizer.cpp

@@ -25,6 +25,7 @@
 
 #include "MeshVisualizer.h"
 
+#include <Corrade/Containers/EnumSet.hpp>
 #include <Corrade/Containers/Optional.h>
 #include <Corrade/Utility/Resource.h>
 
@@ -152,4 +153,25 @@ MeshVisualizer::MeshVisualizer(const Flags flags): _flags{flags} {
     #endif
 }
 
+Debug& operator<<(Debug& debug, const MeshVisualizer::Flag value) {
+    switch(value) {
+        /* LCOV_EXCL_START */
+        #define _c(v) case MeshVisualizer::Flag::v: return debug << "Shaders::MeshVisualizer::Flag::" #v;
+        _c(NoGeometryShader)
+        _c(Wireframe)
+        #undef _c
+        /* LCOV_EXCL_STOP */
+    }
+
+    return debug << "Shaders::MeshVisualizer::Flag(" << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(value)) << Debug::nospace << ")";
+}
+
+Debug& operator<<(Debug& debug, const MeshVisualizer::Flags value) {
+    return Containers::enumSetDebugOutput(debug, value, "Shaders::MeshVisualizer::Flags{}", {
+        MeshVisualizer::Flag::Wireframe,
+        /* Wireframe contains this on ES2 so it's not reported there */
+        MeshVisualizer::Flag::NoGeometryShader
+    });
+}
+
 }}

src/Magnum/Shaders/MeshVisualizer.h

@@ -185,6 +185,9 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizer: public GL::AbstractShaderProgram {
         /** @brief Move assignment */
         MeshVisualizer& operator=(MeshVisualizer&&) noexcept = default;
 
+        /** @brief Flags */
+        Flags flags() const { return _flags; }
+
         /**
          * @brief Set transformation and projection matrix
          * @return Reference to self (for method chaining)
@@ -263,6 +266,12 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizer: public GL::AbstractShaderProgram {
             _smoothnessUniform{5};
 };
 
+/** @debugoperatorclassenum{MeshVisualizer,MeshVisualizer::Flag} */
+MAGNUM_SHADERS_EXPORT Debug& operator<<(Debug& debug, MeshVisualizer::Flag value);
+
+/** @debugoperatorclassenum{MeshVisualizer,MeshVisualizer::Flags} */
+MAGNUM_SHADERS_EXPORT Debug& operator<<(Debug& debug, MeshVisualizer::Flags value);
+
 CORRADE_ENUMSET_OPERATORS(MeshVisualizer::Flags)
 
 inline MeshVisualizer& MeshVisualizer::setSmoothness(Float smoothness) {

src/Magnum/Shaders/Phong.cpp

@@ -25,6 +25,7 @@
 
 #include "Phong.h"
 
+#include <Corrade/Containers/EnumSet.hpp>
 #include <Corrade/Utility/Resource.h>
 
 #include "Magnum/GL/Context.h"
@@ -166,4 +167,41 @@ Phong& Phong::setAlphaMask(Float mask) {
     return *this;
 }
 
+Phong& Phong::setLightPositions(const Containers::ArrayView<const Vector3> positions) {
+    CORRADE_ASSERT(_lightCount == positions.size(),
+        "Shaders::Phong::setLightPositions(): expected" << _lightCount << "items but got" << positions.size(), *this);
+    setUniform(_lightPositionsUniform, positions);
+    return *this;
+}
+
+Phong& Phong::setLightColors(const Containers::ArrayView<const Color4> colors) {
+    CORRADE_ASSERT(_lightCount == colors.size(),
+        "Shaders::Phong::setLightColors(): expected" << _lightCount << "items but got" << colors.size(), *this);
+    setUniform(_lightColorsUniform, colors);
+    return *this;
+}
+
+Debug& operator<<(Debug& debug, const Phong::Flag value) {
+    switch(value) {
+        /* LCOV_EXCL_START */
+        #define _c(v) case Phong::Flag::v: return debug << "Shaders::Phong::Flag::" #v;
+        _c(AmbientTexture)
+        _c(DiffuseTexture)
+        _c(SpecularTexture)
+        _c(AlphaMask)
+        #undef _c
+        /* LCOV_EXCL_STOP */
+    }
+
+    return debug << "Shaders::Phong::Flag(" << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(value)) << Debug::nospace << ")";
+}
+
+Debug& operator<<(Debug& debug, const Phong::Flags value) {
+    return Containers::enumSetDebugOutput(debug, value, "Shaders::Phong::Flags{}", {
+        Phong::Flag::AmbientTexture,
+        Phong::Flag::DiffuseTexture,
+        Phong::Flag::SpecularTexture,
+        Phong::Flag::AlphaMask});
+}
+
 }}

src/Magnum/Shaders/Phong.h

@@ -425,6 +425,12 @@ class MAGNUM_SHADERS_EXPORT Phong: public GL::AbstractShaderProgram {
             _alphaMaskUniform{9};
 };
 
+/** @debugoperatorclassenum{Phong,Phong::Flag} */
+MAGNUM_SHADERS_EXPORT Debug& operator<<(Debug& debug, Phong::Flag value);
+
+/** @debugoperatorclassenum{Phong,Phong::Flags} */
+MAGNUM_SHADERS_EXPORT Debug& operator<<(Debug& debug, Phong::Flags value);
+
 CORRADE_ENUMSET_OPERATORS(Phong::Flags)
 
 }}

src/Magnum/Shaders/Test/FlatGLTest.cpp

@@ -89,6 +89,7 @@ template<UnsignedInt dimensions> void FlatGLTest::construct() {
     setTestCaseDescription(data.name);
 
     Flat<dimensions> shader{data.flags};
+    CORRADE_COMPARE(shader.flags(), data.flags);
     {
         #ifdef CORRADE_TARGET_APPLE
         CORRADE_EXPECT_FAIL("macOS drivers need insane amount of state to validate properly.");
@@ -101,7 +102,7 @@ template<UnsignedInt dimensions> void FlatGLTest::construct() {
 template<UnsignedInt dimensions> void FlatGLTest::constructMove() {
     setTestCaseName(Utility::formatString("constructMove<{}>", dimensions));
 
-    Flat<dimensions> a;
+    Flat<dimensions> a{Flat<dimensions>::Flag::Textured};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -109,11 +110,13 @@ template<UnsignedInt dimensions> void FlatGLTest::constructMove() {
 
     Flat<dimensions> b{std::move(a)};
     CORRADE_COMPARE(b.id(), id);
+    CORRADE_COMPARE(b.flags(), Flat<dimensions>::Flag::Textured);
     CORRADE_VERIFY(!a.id());
 
     Flat<dimensions> c{NoCreate};
     c = std::move(b);
     CORRADE_COMPARE(c.id(), id);
+    CORRADE_COMPARE(c.flags(), Flat<dimensions>::Flag::Textured);
     CORRADE_VERIFY(!b.id());
 }
 

src/Magnum/Shaders/Test/FlatTest.cpp

@@ -23,6 +23,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#include <sstream>
 #include <Corrade/TestSuite/Tester.h>
 
 #include "Magnum/Shaders/Flat.h"
@@ -37,6 +38,9 @@ struct FlatTest: TestSuite::Tester {
 
     void constructCopy2D();
     void constructCopy3D();
+
+    void debugFlag();
+    void debugFlags();
 };
 
 FlatTest::FlatTest() {
@@ -44,7 +48,10 @@ FlatTest::FlatTest() {
               &FlatTest::constructNoCreate3D,
 
               &FlatTest::constructCopy2D,
-              &FlatTest::constructCopy3D});
+              &FlatTest::constructCopy3D,
+
+              &FlatTest::debugFlag,
+              &FlatTest::debugFlags});
 }
 
 void FlatTest::constructNoCreate2D() {
@@ -75,6 +82,20 @@ void FlatTest::constructCopy3D() {
     CORRADE_VERIFY(!(std::is_assignable<Flat3D, const Flat3D&>{}));
 }
 
+void FlatTest::debugFlag() {
+    std::ostringstream out;
+
+    Debug{&out} << Flat3D::Flag::Textured << Flat3D::Flag(0xf0);
+    CORRADE_COMPARE(out.str(), "Shaders::Flat::Flag::Textured Shaders::Flat::Flag(0xf0)\n");
+}
+
+void FlatTest::debugFlags() {
+    std::ostringstream out;
+
+    Debug{&out} << (Flat3D::Flag::Textured|Flat3D::Flag::AlphaMask) << Flat3D::Flags{};
+    CORRADE_COMPARE(out.str(), "Shaders::Flat::Flag::Textured|Shaders::Flat::Flag::AlphaMask Shaders::Flat::Flags{}\n");
+}
+
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Shaders::Test::FlatTest)

src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp

@@ -54,6 +54,7 @@ MeshVisualizerGLTest::MeshVisualizerGLTest() {
 
 void MeshVisualizerGLTest::construct() {
     MeshVisualizer shader;
+    CORRADE_COMPARE(shader.flags(), MeshVisualizer::Flags{});
     {
         #ifdef CORRADE_TARGET_APPLE
         CORRADE_EXPECT_FAIL("macOS drivers need insane amount of state to validate properly.");
@@ -78,7 +79,8 @@ void MeshVisualizerGLTest::constructWireframeGeometryShader() {
         Debug() << "Using" << GL::Extensions::NV::shader_noperspective_interpolation::string();
     #endif
 
-    MeshVisualizer shader(MeshVisualizer::Flag::Wireframe);
+    MeshVisualizer shader{MeshVisualizer::Flag::Wireframe};
+    CORRADE_COMPARE(shader.flags(), MeshVisualizer::Flag::Wireframe);
     {
         #ifdef CORRADE_TARGET_APPLE
         CORRADE_EXPECT_FAIL("macOS drivers need insane amount of state to validate properly.");
@@ -90,7 +92,8 @@ void MeshVisualizerGLTest::constructWireframeGeometryShader() {
 #endif
 
 void MeshVisualizerGLTest::constructWireframeNoGeometryShader() {
-    MeshVisualizer shader(MeshVisualizer::Flag::Wireframe|MeshVisualizer::Flag::NoGeometryShader);
+    MeshVisualizer shader{MeshVisualizer::Flag::Wireframe|MeshVisualizer::Flag::NoGeometryShader};
+    CORRADE_COMPARE(shader.flags(), MeshVisualizer::Flag::Wireframe|MeshVisualizer::Flag::NoGeometryShader);
     {
         #ifdef CORRADE_TARGET_APPLE
         CORRADE_EXPECT_FAIL("macOS drivers need insane amount of state to validate properly.");
@@ -101,7 +104,7 @@ void MeshVisualizerGLTest::constructWireframeNoGeometryShader() {
 }
 
 void MeshVisualizerGLTest::constructMove() {
-    MeshVisualizer a;
+    MeshVisualizer a{MeshVisualizer::Flag::Wireframe|MeshVisualizer::Flag::NoGeometryShader};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -109,11 +112,13 @@ void MeshVisualizerGLTest::constructMove() {
 
     MeshVisualizer b{std::move(a)};
     CORRADE_COMPARE(b.id(), id);
+    CORRADE_COMPARE(b.flags(), MeshVisualizer::Flag::Wireframe|MeshVisualizer::Flag::NoGeometryShader);
     CORRADE_VERIFY(!a.id());
 
     MeshVisualizer c{NoCreate};
     c = std::move(b);
     CORRADE_COMPARE(c.id(), id);
+    CORRADE_COMPARE(c.flags(), MeshVisualizer::Flag::Wireframe|MeshVisualizer::Flag::NoGeometryShader);
     CORRADE_VERIFY(!b.id());
 }
 

src/Magnum/Shaders/Test/MeshVisualizerTest.cpp

@@ -23,6 +23,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#include <sstream>
 #include <Corrade/TestSuite/Tester.h>
 
 #include "Magnum/Shaders/MeshVisualizer.h"
@@ -34,11 +35,17 @@ struct MeshVisualizerTest: TestSuite::Tester {
 
     void constructNoCreate();
     void constructCopy();
+
+    void debugFlag();
+    void debugFlags();
 };
 
 MeshVisualizerTest::MeshVisualizerTest() {
     addTests({&MeshVisualizerTest::constructNoCreate,
-              &MeshVisualizerTest::constructCopy});
+              &MeshVisualizerTest::constructCopy,
+
+              &MeshVisualizerTest::debugFlag,
+              &MeshVisualizerTest::debugFlags});
 }
 
 void MeshVisualizerTest::constructNoCreate() {
@@ -55,6 +62,24 @@ void MeshVisualizerTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<MeshVisualizer, const MeshVisualizer&>{}));
 }
 
+void MeshVisualizerTest::debugFlag() {
+    std::ostringstream out;
+
+    Debug{&out} << MeshVisualizer::Flag::Wireframe << MeshVisualizer::Flag(0xf0);
+    CORRADE_COMPARE(out.str(), "Shaders::MeshVisualizer::Flag::Wireframe Shaders::MeshVisualizer::Flag(0xf0)\n");
+}
+
+void MeshVisualizerTest::debugFlags() {
+    std::ostringstream out;
+
+    Debug{&out} << (MeshVisualizer::Flag::Wireframe|MeshVisualizer::Flag::NoGeometryShader) << MeshVisualizer::Flags{};
+    #ifndef MAGNUM_TARGET_GLES2
+    CORRADE_COMPARE(out.str(), "Shaders::MeshVisualizer::Flag::Wireframe|Shaders::MeshVisualizer::Flag::NoGeometryShader Shaders::MeshVisualizer::Flags{}\n");
+    #else
+    CORRADE_COMPARE(out.str(), "Shaders::MeshVisualizer::Flag::Wireframe Shaders::MeshVisualizer::Flags{}\n");
+    #endif
+}
+
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Shaders::Test::MeshVisualizerTest)

src/Magnum/Shaders/Test/PhongGLTest.cpp

@@ -81,6 +81,7 @@ void PhongGLTest::construct() {
     setTestCaseDescription(data.name);
 
     Phong shader{data.flags};
+    CORRADE_COMPARE(shader.flags(), data.flags);
     {
         #ifdef CORRADE_TARGET_APPLE
         CORRADE_EXPECT_FAIL("macOS drivers need insane amount of state to validate properly.");
@@ -91,7 +92,7 @@ void PhongGLTest::construct() {
 }
 
 void PhongGLTest::constructMove() {
-    Phong a;
+    Phong a{Phong::Flag::AlphaMask};
     const GLuint id = a.id();
     CORRADE_VERIFY(id);
 
@@ -99,11 +100,13 @@ void PhongGLTest::constructMove() {
 
     Phong b{std::move(a)};
     CORRADE_COMPARE(b.id(), id);
+    CORRADE_COMPARE(b.flags(), Phong::Flag::AlphaMask);
     CORRADE_VERIFY(!a.id());
 
     Phong c{NoCreate};
     c = std::move(b);
     CORRADE_COMPARE(c.id(), id);
+    CORRADE_COMPARE(c.flags(), Phong::Flag::AlphaMask);
     CORRADE_VERIFY(!b.id());
 }
 

src/Magnum/Shaders/Test/PhongTest.cpp

@@ -23,6 +23,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#include <sstream>
 #include <Corrade/TestSuite/Tester.h>
 
 #include "Magnum/Shaders/Phong.h"
@@ -34,11 +35,17 @@ struct PhongTest: TestSuite::Tester {
 
     void constructNoCreate();
     void constructCopy();
+
+    void debugFlag();
+    void debugFlags();
 };
 
 PhongTest::PhongTest() {
     addTests({&PhongTest::constructNoCreate,
-              &PhongTest::constructCopy});
+              &PhongTest::constructCopy,
+
+              &PhongTest::debugFlag,
+              &PhongTest::debugFlags});
 }
 
 void PhongTest::constructNoCreate() {
@@ -55,6 +62,20 @@ void PhongTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<Phong, const Phong&>{}));
 }
 
+void PhongTest::debugFlag() {
+    std::ostringstream out;
+
+    Debug{&out} << Phong::Flag::AmbientTexture << Phong::Flag(0xf0);
+    CORRADE_COMPARE(out.str(), "Shaders::Phong::Flag::AmbientTexture Shaders::Phong::Flag(0xf0)\n");
+}
+
+void PhongTest::debugFlags() {
+    std::ostringstream out;
+
+    Debug{&out} << (Phong::Flag::DiffuseTexture|Phong::Flag::SpecularTexture) << Phong::Flags{};
+    CORRADE_COMPARE(out.str(), "Shaders::Phong::Flag::DiffuseTexture|Shaders::Phong::Flag::SpecularTexture Shaders::Phong::Flags{}\n");
+}
+
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Shaders::Test::PhongTest)