/* This file is part of Magnum. Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025 Vladimír Vondruš Copyright © 2020 Jonathan Hale Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include #include #include #include #include #include #include #include #include "Magnum/Image.h" #include "Magnum/ImageView.h" #include "Magnum/Mesh.h" #include "Magnum/PixelFormat.h" #include "Magnum/DebugTools/CompareImage.h" #include "Magnum/GL/Context.h" #include "Magnum/GL/Extensions.h" #include "Magnum/GL/Mesh.h" #include "Magnum/GL/OpenGLTester.h" #include "Magnum/GL/Framebuffer.h" #include "Magnum/GL/Renderbuffer.h" #include "Magnum/GL/RenderbufferFormat.h" #include "Magnum/GL/Texture.h" #include "Magnum/GL/TextureFormat.h" #include "Magnum/Math/Color.h" #include "Magnum/Math/Half.h" #include "Magnum/Math/Matrix3.h" #include "Magnum/Math/Matrix4.h" #include "Magnum/MeshTools/Compile.h" #include "Magnum/MeshTools/Duplicate.h" #include "Magnum/Shaders/FlatGL.h" #include "Magnum/Shaders/PhongGL.h" #include "Magnum/Shaders/VertexColorGL.h" #include "Magnum/Shaders/MeshVisualizerGL.h" #include "Magnum/Trade/AbstractImporter.h" #include "Magnum/Trade/MeshData.h" #ifdef MAGNUM_BUILD_DEPRECATED #define _MAGNUM_NO_DEPRECATED_MESHDATA /* So it doesn't yell here */ #include "Magnum/Trade/MeshData2D.h" #include "Magnum/Trade/MeshData3D.h" #endif #include "configure.h" namespace Magnum { namespace MeshTools { namespace Test { namespace { enum class Flag { NonIndexed = 1 << 0, Tangents = 1 << 1, Bitangents = 1 << 2, BitangentsFromTangents = 1 << 3, Normals = 1 << 4, GeneratedFlatNormals = 1 << 5, GeneratedSmoothNormals = 1 << 6, TextureCoordinates2D = 1 << 7, Colors = 1 << 8, ObjectId = 1 << 9 }; typedef Containers::EnumSet Flags; #ifdef CORRADE_TARGET_CLANG #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunused-function" #endif CORRADE_ENUMSET_OPERATORS(Flags) #ifdef CORRADE_TARGET_CLANG #pragma clang diagnostic pop #endif struct CompileGLTest: GL::OpenGLTester { explicit CompileGLTest(); void renderSetup(); void renderTeardown(); /** @todo remove the template once MeshDataXD is gone */ template void twoDimensions(); template void threeDimensions(); void packedAttributes(); #ifndef MAGNUM_TARGET_GLES2 /* Tests also compiledPerVertexJointCount() */ void skinning(); void skinningPackedAttributes(); #endif void conflictingAttributes(); void unsupportedIndexStride(); void morphTargetAttributes(); void customAttribute(); void unsupportedAttribute(); void unsupportedAttributeStride(); void implementationSpecificAttributeFormat(); void generateNormalsNoPosition(); void generateNormals2DPosition(); void generateNormalsNoFloats(); void externalBuffers(); void externalBuffersInvalid(); private: PluginManager::Manager _manager{"nonexistent"}; Shaders::FlatGL2D _flat2D; Shaders::FlatGL2D _flatTextured2D{Shaders::FlatGL2D::Configuration{} .setFlags(Shaders::FlatGL2D::Flag::Textured)}; #ifndef MAGNUM_TARGET_GLES2 Shaders::FlatGL2D _flatObjectId2D{NoCreate}; #endif Shaders::FlatGL3D _flat3D; Shaders::FlatGL3D _flatTextured3D{Shaders::FlatGL3D::Configuration{} .setFlags(Shaders::FlatGL3D::Flag::Textured)}; #ifndef MAGNUM_TARGET_GLES2 Shaders::FlatGL3D _flatObjectId3D{NoCreate}; #endif Shaders::VertexColorGL2D _color2D; Shaders::VertexColorGL3D _color3D; Shaders::PhongGL _phong; #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL) Shaders::MeshVisualizerGL3D _meshVisualizer3D{NoCreate}; Shaders::MeshVisualizerGL3D _meshVisualizerBitangentsFromTangents3D{NoCreate}; #endif GL::Renderbuffer _color; #ifndef MAGNUM_TARGET_GLES2 GL::Renderbuffer _objectId; #endif GL::Framebuffer _framebuffer{{{}, {32, 32}}}; GL::Texture2D _texture; }; const struct { const char* name; Flags flags; Containers::Optional indexType; } Data2D[] { {"positions", {}, {}}, {"positions, implementation-specific index type", {}, meshIndexTypeWrap(GL_UNSIGNED_INT)}, {"positions, nonindexed", Flag::NonIndexed, {}}, {"positions + colors", Flag::Colors, {}}, {"positions + texture coordinates", Flag::TextureCoordinates2D, {}}, {"positions + texture coordinates + colors", Flag::TextureCoordinates2D|Flag::Colors, {}}, {"positions, object id, nonindexed", Flag::ObjectId|Flag::NonIndexed, {}} }; const struct { const char* name; Flags flags; Containers::Optional indexType; } Data3D[] { {"positions", {}, {}}, {"positions, implementation-specific index type", {}, meshIndexTypeWrap(GL_UNSIGNED_BYTE)}, {"positions, nonindexed", Flag::NonIndexed, {}}, {"positions + colors", Flag::Colors, {}}, {"positions + texcoords", Flag::TextureCoordinates2D,{}}, {"positions + texcoords + colors", Flag::TextureCoordinates2D|Flag::Colors, {}}, {"positions + normals", Flag::Normals, {}}, {"positions + normals + colors", Flag::Normals|Flag::Colors,{}}, {"positions + normals + texcoords", Flag::Normals|Flag::TextureCoordinates2D, {}}, {"positions + normals + texcoords + colors", Flag::Normals|Flag::TextureCoordinates2D|Flag::Colors, {}}, {"positions + gen flat normals", Flag::GeneratedFlatNormals, {}}, {"positions + gen both smooth and flat normals", Flag::GeneratedSmoothNormals|Flag::GeneratedFlatNormals, {}}, {"positions + normals, gen flat normals", Flag::Normals|Flag::GeneratedFlatNormals, {}}, {"positions + gen flat normals + colors", Flag::GeneratedFlatNormals|Flag::Colors, {}}, {"positions + gen flat normals + texcoords", Flag::GeneratedFlatNormals|Flag::TextureCoordinates2D, {}}, {"positions + gen flat normals + texcoords + colors", Flag::NonIndexed|Flag::GeneratedFlatNormals|Flag::TextureCoordinates2D|Flag::Colors, {}}, {"positions, nonindexed + gen flat normals", Flag::NonIndexed|Flag::GeneratedFlatNormals, {}}, {"positions, nonindexed + gen flat normals + colors", Flag::NonIndexed|Flag::GeneratedFlatNormals|Flag::Colors, {}}, {"positions, nonindexed + gen flat normals + texcoords", Flag::NonIndexed|Flag::GeneratedFlatNormals|Flag::TextureCoordinates2D, {}}, {"positions, nonindexed + gen flat normals + texcoords + colors", Flag::NonIndexed|Flag::GeneratedFlatNormals|Flag::TextureCoordinates2D|Flag::Colors, {}}, {"positions, gen smooth normals", Flag::GeneratedSmoothNormals, {}}, {"positions, gen smooth normals + colors", Flag::GeneratedSmoothNormals|Flag::Colors, {}}, {"positions, gen smooth normals + texcoords", Flag::GeneratedSmoothNormals|Flag::TextureCoordinates2D, {}}, {"positions, gen smooth normals + texcoords + colors", Flag::GeneratedSmoothNormals|Flag::TextureCoordinates2D|Flag::Colors, {}}, {"positions, nonindexed + gen smooth normals", Flag::NonIndexed|Flag::GeneratedSmoothNormals, {}}, {"positions, tangents, bitangents, normals", Flag::Tangents|Flag::Bitangents|Flag::Normals, {}}, {"positions, tangents, bitangents from tangents, normals", Flag::Tangents|Flag::BitangentsFromTangents|Flag::Normals, {}}, {"positions, object id, nonindexed", Flag::ObjectId|Flag::NonIndexed, {}} }; constexpr std::ptrdiff_t SkinningDataStride = sizeof(Vector2) + 7*sizeof(UnsignedInt) + 7*sizeof(Float); const struct { const char* name; Containers::Array attributes; UnsignedInt expectedJointCount, expectedSecondaryJointCount; const char* expectedMessage; } SkinningData[]{ /* First two and last two weights are zeros thus the middle 3 components are enough to give the full output */ {"single 3-component attribute", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2) + 2*sizeof(UnsignedInt), 4, SkinningDataStride, 3}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt) + 2*sizeof(Float), 4, SkinningDataStride, 3}, }}, 3, 0, ""}, {"single 7-component attribute", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2), 4, SkinningDataStride, 7}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt), 4, SkinningDataStride, 7}, }}, 4, 3, ""}, {"3-component and a 4-component attribute", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2), 4, SkinningDataStride, 3}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt), 4, SkinningDataStride, 3}, Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2) + 3*sizeof(UnsignedInt), 4, SkinningDataStride, 4}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt) + 3*sizeof(Float), 4, SkinningDataStride, 4}, }}, 3, 4, ""}, {"4-component and a 3-component attribute", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2), 4, SkinningDataStride, 4}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt), 4, SkinningDataStride, 4}, Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2) + 4*sizeof(UnsignedInt), 4, SkinningDataStride, 3}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt) + 4*sizeof(Float), 4, SkinningDataStride, 3}, }}, 4, 3, ""}, {"1-component and a 5-component attribute", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2) + 1*sizeof(UnsignedInt), 4, SkinningDataStride, 1}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt) + 1*sizeof(Float), 4, SkinningDataStride, 1}, Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2) + 2*sizeof(UnsignedInt), 4, SkinningDataStride, 5}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt) + 2*sizeof(Float), 4, SkinningDataStride, 5}, }}, 1, 4, "MeshTools::compile(): ignoring remaining 1 components of joint ID / weights attribute 1, only two sets are supported at most\n"}, {"3-component, 2-component and a 2-component attribute", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2), 4, SkinningDataStride, 3}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt), 4, SkinningDataStride, 3}, Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2) + 3*sizeof(UnsignedInt), 4, SkinningDataStride, 2}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt) + 3*sizeof(Float), 4, SkinningDataStride, 2}, Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2) + 5*sizeof(UnsignedInt), 4, SkinningDataStride, 2}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt) + 5*sizeof(Float), 4, SkinningDataStride, 2}, }}, 3, 2, "MeshTools::compile(): ignoring joint ID / weights attribute 2, only two sets are supported at most\n"}, {"single 7-component attribute, and then a 9-component attribute", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, sizeof(Vector2), 4, SkinningDataStride, 7}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, sizeof(Vector2) + 7*sizeof(UnsignedInt), 4, SkinningDataStride, 7}, Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedInt, 0, 4, SkinningDataStride, 9}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, 0, 4, SkinningDataStride, 9}, /* The warning should be printed just once for the whole attribute, not again for every group of four components */ }}, 4, 3, "MeshTools::compile(): ignoring joint ID / weights attribute 1, only two sets are supported at most\n"}, }; constexpr std::ptrdiff_t ConflictingAttributesDataStride = 3*sizeof(Vector2) + sizeof(UnsignedInt) + sizeof(Vector3); const struct { const char* name; Containers::Array attributes; Flags flags; UnsignedInt expectedObjectId; const char* expected; const char* expectedMessage; } ConflictingAttributesData[]{ /* The position atribute is added in the test */ {"multiple texture coordinates", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::TextureCoordinates, VertexFormat::Vector2, sizeof(Vector2), 9, ConflictingAttributesDataStride}, Trade::MeshAttributeData{Trade::MeshAttribute::TextureCoordinates, VertexFormat::Vector2, 2*sizeof(Vector2), 9, ConflictingAttributesDataStride}, }}, Flag::TextureCoordinates2D, 0, "textured2D.tga", "ignoring Trade::MeshAttribute::TextureCoordinates 1 as its binding slot is already occupied by Trade::MeshAttribute::TextureCoordinates 0"}, #ifndef MAGNUM_TARGET_GLES2 {"bitangents + object ID", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::Bitangent, VertexFormat::Vector3, 3*sizeof(Vector2) + sizeof(UnsignedInt), 9, ConflictingAttributesDataStride}, Trade::MeshAttributeData{Trade::MeshAttribute::ObjectId, VertexFormat::UnsignedInt, 3*sizeof(Vector2), 9, ConflictingAttributesDataStride}, }}, Flag::ObjectId, 0, "flat2D.tga", "ignoring Trade::MeshAttribute::ObjectId 0 as its binding slot is already occupied by Trade::MeshAttribute::Bitangent 0"}, {"object ID + bitangents", {InPlaceInit, { Trade::MeshAttributeData{Trade::MeshAttribute::ObjectId, VertexFormat::UnsignedInt, 3*sizeof(Vector2), 9, ConflictingAttributesDataStride}, Trade::MeshAttributeData{Trade::MeshAttribute::Bitangent, VertexFormat::Vector3, 3*sizeof(Vector2) + sizeof(UnsignedInt), 9, ConflictingAttributesDataStride}, }}, Flag::ObjectId, 26234, "flat2D.tga", "ignoring Trade::MeshAttribute::Bitangent 0 as its binding slot is already occupied by Trade::MeshAttribute::ObjectId 0"}, #endif /* Conflicting skinning attributes tested directly in skinning() */ /** @todo test also a conflict with instanced transformation + secondary joints & weights, once instanced transformation is a builtin attribute */ }; constexpr struct { const char* name; CompileFlags flags; } CustomAttributeWarningData[] { {"", {}}, {"no warning", CompileFlag::NoWarnOnCustomAttributes} }; constexpr struct { const char* name; bool indexed, moveIndices, moveVertices; } DataExternal[] { {"indexed", true, false, false}, {"", false, false, false}, {"move indices", true, true, false}, {"move vertices", false, false, true}, {"move both", true, true, true} }; using namespace Math::Literals; constexpr Color4ub ImageData[] { 0xff000000_rgba, 0x80000000_rgba, 0x00008000_rgba, 0x0000ff00_rgba, 0x80000000_rgba, 0xffffffff_rgba, 0xffffffff_rgba, 0x00008000_rgba, 0x00800000_rgba, 0xffffffff_rgba, 0xffffffff_rgba, 0x00008000_rgba, 0x00ff0000_rgba, 0x00800000_rgba, 0x00000080_rgba, 0x000000ff_rgba }; CompileGLTest::CompileGLTest() { addInstancedTests({ &CompileGLTest::twoDimensions}, Containers::arraySize(Data2D), &CompileGLTest::renderSetup, &CompileGLTest::renderTeardown); #ifdef MAGNUM_BUILD_DEPRECATED CORRADE_IGNORE_DEPRECATED_PUSH addInstancedTests({ &CompileGLTest::twoDimensions}, Containers::arraySize(Data2D), &CompileGLTest::renderSetup, &CompileGLTest::renderTeardown); CORRADE_IGNORE_DEPRECATED_POP #endif addInstancedTests({ &CompileGLTest::threeDimensions}, Containers::arraySize(Data3D), &CompileGLTest::renderSetup, &CompileGLTest::renderTeardown); #ifdef MAGNUM_BUILD_DEPRECATED CORRADE_IGNORE_DEPRECATED_PUSH addInstancedTests({ &CompileGLTest::threeDimensions}, Containers::arraySize(Data3D), &CompileGLTest::renderSetup, &CompileGLTest::renderTeardown); CORRADE_IGNORE_DEPRECATED_POP #endif addTests({&CompileGLTest::packedAttributes}, &CompileGLTest::renderSetup, &CompileGLTest::renderTeardown); #ifndef MAGNUM_TARGET_GLES2 addInstancedTests({&CompileGLTest::skinning}, Containers::arraySize(SkinningData), &CompileGLTest::renderSetup, &CompileGLTest::renderTeardown); addTests({&CompileGLTest::skinningPackedAttributes}, &CompileGLTest::renderSetup, &CompileGLTest::renderTeardown); #endif addInstancedTests({&CompileGLTest::conflictingAttributes}, Containers::arraySize(ConflictingAttributesData), &CompileGLTest::renderSetup, &CompileGLTest::renderTeardown); addTests({&CompileGLTest::unsupportedIndexStride}); addInstancedTests({&CompileGLTest::morphTargetAttributes, &CompileGLTest::customAttribute, &CompileGLTest::unsupportedAttribute}, Containers::arraySize(CustomAttributeWarningData)); addTests({&CompileGLTest::unsupportedAttributeStride}); addInstancedTests({&CompileGLTest::implementationSpecificAttributeFormat}, Containers::arraySize(CustomAttributeWarningData)); addTests({&CompileGLTest::generateNormalsNoPosition, &CompileGLTest::generateNormals2DPosition, &CompileGLTest::generateNormalsNoFloats}); addInstancedTests({&CompileGLTest::externalBuffers}, Containers::arraySize(DataExternal), &CompileGLTest::renderSetup, &CompileGLTest::renderTeardown); addTests({&CompileGLTest::externalBuffersInvalid}); /* Load the plugins directly from the build tree. Otherwise they're either static and already loaded or not present in the build tree */ #ifdef ANYIMAGEIMPORTER_PLUGIN_FILENAME CORRADE_INTERNAL_ASSERT_OUTPUT(_manager.load(ANYIMAGEIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded); #endif #ifdef TGAIMPORTER_PLUGIN_FILENAME CORRADE_INTERNAL_ASSERT_OUTPUT(_manager.load(TGAIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded); #endif /* Set up the rendering */ _color.setStorage( #if !defined(MAGNUM_TARGET_GLES2) || !defined(MAGNUM_TARGET_WEBGL) GL::RenderbufferFormat::RGBA8, #else GL::RenderbufferFormat::RGBA4, #endif {32, 32}); _framebuffer .attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, _color) .bind(); _texture .setMinificationFilter(SamplerFilter::Linear) .setMagnificationFilter(SamplerFilter::Linear) .setWrapping(SamplerWrapping::ClampToEdge) .setStorage(1, #if !defined(MAGNUM_TARGET_GLES2) || !defined(MAGNUM_TARGET_WEBGL) GL::TextureFormat::RGBA8, #else GL::TextureFormat::RGBA, #endif {4, 4}) .setSubImage(0, {}, ImageView2D{PixelFormat::RGBA8Unorm, {4, 4}, ImageData}); /* Use a point light instead of a directional light to better highlight the difference in normals; disable specular as that only causes unnecessary rounding errors across GPUs */ _phong.setLightPositions({{0.0f, 0.0f, -0.0f, 1.0f}}) .setLightColors({0xffffff_rgbf*5.0f}) .setSpecularColor(0x00000000_rgbaf); #ifndef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_GLES if(GL::Context::current().isExtensionSupported()) #endif { _flatObjectId2D = Shaders::FlatGL2D{Shaders::FlatGL2D::Configuration{} .setFlags(Shaders::FlatGL2D::Flag::InstancedObjectId)}; _flatObjectId3D = Shaders::FlatGL3D{Shaders::FlatGL3D::Configuration{} .setFlags(Shaders::FlatGL3D::Flag::InstancedObjectId)}; _objectId.setStorage(GL::RenderbufferFormat::R32UI, {32, 32}); _framebuffer .attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, _objectId) .mapForDraw({ {Shaders::GenericGL3D::ColorOutput, GL::Framebuffer::ColorAttachment{0}}, {Shaders::GenericGL3D::ObjectIdOutput, GL::Framebuffer::ColorAttachment{1}} }); } #endif /* Mesh visualizer shaders only if we have a GS */ #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL) #ifndef MAGNUM_TARGET_GLES if(GL::Context::current().isExtensionSupported()) #else if(GL::Context::current().isExtensionSupported()) #endif { _meshVisualizer3D = Shaders::MeshVisualizerGL3D{Shaders::MeshVisualizerGL3D::Configuration{} .setFlags(Shaders::MeshVisualizerGL3D::Flag::TangentDirection| Shaders::MeshVisualizerGL3D::Flag::BitangentDirection| Shaders::MeshVisualizerGL3D::Flag::NormalDirection)}; _meshVisualizerBitangentsFromTangents3D = Shaders::MeshVisualizerGL3D{Shaders::MeshVisualizerGL3D::Configuration{} .setFlags(Shaders::MeshVisualizerGL3D::Flag::TangentDirection| Shaders::MeshVisualizerGL3D::Flag::BitangentFromTangentDirection| Shaders::MeshVisualizerGL3D::Flag::NormalDirection)}; } #endif } template struct MeshTypeName; template<> struct MeshTypeName { static const char* name() { return "Trade::MeshData"; } }; #ifdef MAGNUM_BUILD_DEPRECATED CORRADE_IGNORE_DEPRECATED_PUSH template<> struct MeshTypeName { static const char* name() { return "Trade::MeshData2D"; } }; template<> struct MeshTypeName { static const char* name() { return "Trade::MeshData3D"; } }; CORRADE_IGNORE_DEPRECATED_POP #endif void CompileGLTest::renderSetup() { #ifndef MAGNUM_TARGET_GLES2 /* To avoid reading from the integer object ID attachment */ /** @todo ugh this needs to be a global thing and managed through scoped RendererState */ _framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{0}); #endif } void CompileGLTest::renderTeardown() {} template void CompileGLTest::twoDimensions() { setTestCaseTemplateName(MeshTypeName::name()); auto&& data = Data2D[testCaseInstanceId()]; setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(data.flags & Flag::ObjectId && !GL::Context::current().isExtensionSupported()) CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported."); #endif #ifdef MAGNUM_BUILD_DEPRECATED CORRADE_IGNORE_DEPRECATED_PUSH /** @todo remove once MeshDataXD is gone */ if(std::is_same::value && ((data.flags & Flag::ObjectId) || data.indexType)) CORRADE_SKIP("Not possible with MeshData2D."); CORRADE_IGNORE_DEPRECATED_POP #endif /* Object ID initially set to the same value, bottom half changed to 13562 after the mesh gets deindexed. 6-----7-----8 | /| /| | / | / | |/ |/ | 3-----4-----5 | /| /| | / | / | |/ |/ | 0-----1-----2 */ const struct Vertex { Vector2 position; Vector2 textureCoordinates; Color3 color; UnsignedInt objectId; } vertexData[]{ {{-0.75f, -0.75f}, {0.0f, 0.0f}, 0x00ff00_rgbf, 26234}, {{ 0.00f, -0.75f}, {0.5f, 0.0f}, 0x808000_rgbf, 26234}, {{ 0.75f, -0.75f}, {1.0f, 0.0f}, 0xff0000_rgbf, 26234}, {{-0.75f, 0.00f}, {0.0f, 0.5f}, 0x00ff80_rgbf, 26234}, {{ 0.00f, 0.00f}, {0.5f, 0.5f}, 0x808080_rgbf, 26234}, {{ 0.75f, 0.00f}, {1.0f, 0.5f}, 0xff0080_rgbf, 26234}, {{-0.75f, 0.75f}, {0.0f, 1.0f}, 0x00ffff_rgbf, 26234}, {{ 0.0f, 0.75f}, {0.5f, 1.0f}, 0x8080ff_rgbf, 26234}, {{ 0.75f, 0.75f}, {1.0f, 1.0f}, 0xff00ff_rgbf, 26234} }; auto vertices = Containers::stridedArrayView(vertexData); Containers::Array attributeData; arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::Position, vertices.slice(&Vertex::position)); if(data.flags & Flag::TextureCoordinates2D) arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::TextureCoordinates, vertices.slice(&Vertex::textureCoordinates)); if(data.flags & Flag::Colors) arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::Color, vertices.slice(&Vertex::color)); if(data.flags & Flag::ObjectId) arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::ObjectId, vertices.slice(&Vertex::objectId)); const UnsignedInt indexData[]{ 66, 78, 23, /* offset */ 0, 1, 4, 0, 4, 3, 1, 2, 5, 1, 5, 4, 3, 4, 7, 3, 7, 6, 4, 5, 8, 4, 8, 7 }; Trade::MeshIndexData indices; if(data.indexType) indices = Trade::MeshIndexData{*data.indexType, Containers::stridedArrayView(Containers::arrayView(indexData).exceptPrefix(3))}; else indices = Trade::MeshIndexData{Containers::arrayView(indexData).exceptPrefix(3)}; Trade::MeshData meshData{MeshPrimitive::Triangles, {}, indexData, indices, {}, vertexData, Utility::move(attributeData)}; /* Duplicate everything if data is non-indexed */ if(data.flags & Flag::NonIndexed) { meshData = duplicate(meshData); /* Update object IDs in the bottom half */ if(data.flags & Flag::ObjectId) { auto objectIds = meshData.mutableAttribute(Trade::MeshAttribute::ObjectId); for(std::size_t i = 0; i != meshData.vertexCount()/2; ++i) objectIds[i] = 13562; } } MAGNUM_VERIFY_NO_GL_ERROR(); #ifdef MAGNUM_BUILD_DEPRECATED CORRADE_IGNORE_DEPRECATED_PUSH /** @todo remove once MeshDataXD is gone */ #endif GL::Mesh mesh = compile(T{Utility::move(meshData)}); #ifdef MAGNUM_BUILD_DEPRECATED CORRADE_IGNORE_DEPRECATED_POP #endif MAGNUM_VERIFY_NO_GL_ERROR(); if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) || !(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); /* Check with the flat shader, it should always work */ { _framebuffer.clear(GL::FramebufferClear::Color); _flat2D .setColor(0xff3366_rgbf) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/flat2D.tga"), (DebugTools::CompareImageToFile{_manager})); } /* Check with the colored shader, if we have colors */ if(data.flags & Flag::Colors) { _framebuffer.clear(GL::FramebufferClear::Color); _color2D.draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/color2D.tga"), (DebugTools::CompareImageToFile{_manager})); } /* Check with the textured shader, if we have texture coords */ if(data.flags & Flag::TextureCoordinates2D) { _framebuffer.clear(GL::FramebufferClear::Color); _flatTextured2D .bindTexture(_texture) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/textured2D.tga"), /* SwiftShader has some minor off-by-one precision differences, llvmpipe as well */ (DebugTools::CompareImageToFile{_manager, 1.75f, 0.22f})); } #ifndef MAGNUM_TARGET_GLES2 /* Check object ID rendering, if we have per-vertex object ID */ if(data.flags & Flag::ObjectId) { _framebuffer.clearColor(1, Vector4ui{27}); _flatObjectId2D.draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); /* Object ID -- no need to verify the whole image, just check that pixels on known places have expected values. SwiftShader insists that the read format has to be 32bit, so the renderbuffer format is that too to make it the same (ES3 Mesa complains if these don't match). */ _framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{1}); CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete); Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::R32UI}); MAGNUM_VERIFY_NO_GL_ERROR(); /* Outside of the object, cleared to 27 */ CORRADE_COMPARE(image.pixels()[2][2], 27); /* Inside of the object, bottom and top half should be different */ CORRADE_COMPARE(image.pixels()[11][18], 13562); CORRADE_COMPARE(image.pixels()[19][15], 26234); } #endif } template void CompileGLTest::threeDimensions() { setTestCaseTemplateName(MeshTypeName::name()); auto&& data = Data3D[testCaseInstanceId()]; setTestCaseDescription(data.name); #ifndef MAGNUM_TARGET_GLES if(data.flags & Flag::ObjectId && !GL::Context::current().isExtensionSupported()) CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported."); #endif #ifdef MAGNUM_BUILD_DEPRECATED CORRADE_IGNORE_DEPRECATED_PUSH /** @todo remove once MeshDataXD is gone */ if(std::is_same::value && ((data.flags & (Flag::Tangents|Flag::Bitangents|Flag::BitangentsFromTangents|Flag::ObjectId)) || data.indexType)) CORRADE_SKIP("Not possible with MeshData3D."); CORRADE_IGNORE_DEPRECATED_POP #endif /* Object ID initially set to the same value, bottom half changed to 13562 after the mesh gets deindexed. 6-----7-----8 | /| /| | / | / | |/ |/ | 3-----4-----5 | /| /| | / | / | |/ |/ | 0-----1-----2 */ struct Vertex { Vector3 position; Vector4 tangent; Vector3 bitangent; Vector3 normal; Vector2 textureCoordinates; Color4 color; UnsignedInt objectId; } vertexData[]{ {{-0.75f, -0.75f, -0.35f}, Vector4{Vector3{1.0f, 0.5f, 0.5f}.normalized(), -1.0f}, {}, Vector3{-0.5f, -0.5f, 1.0f}.normalized(), {0.0f, 0.0f}, 0x00ff00_rgbf, 26234}, {{ 0.00f, -0.75f, -0.25f}, Vector4{Vector3{1.0f, 0.0f, 0.5f}.normalized(), 1.0f}, {}, Vector3{ 0.0f, -0.5f, 1.0f}.normalized(), {0.5f, 0.0f}, 0x808000_rgbf, 26234}, {{ 0.75f, -0.75f, -0.35f}, Vector4{Vector3{1.0f, -0.5f, 0.5f}.normalized(), 1.0f}, {}, Vector3{ 0.5f, -0.5f, 1.0f}.normalized(), {1.0f, 0.0f}, 0xff0000_rgbf, 26234}, {{-0.75f, 0.00f, -0.25f}, Vector4{Vector3{1.0f, 0.5f, 0.0f}.normalized(), -1.0f}, {}, Vector3{-0.5f, 0.0f, 1.0f}.normalized(), {0.0f, 0.5f}, 0x00ff80_rgbf, 26234}, {{ 0.00f, 0.00f, 0.00f}, Vector4{Vector3{1.0f, 0.0f, 0.0f}.normalized(), 1.0f}, {}, Vector3{ 0.0f, 0.0f, 1.0f}.normalized(), {0.5f, 0.5f}, 0x808080_rgbf, 26234}, {{ 0.75f, 0.00f, -0.25f}, Vector4{Vector3{1.0f, -0.5f, 0.0f}.normalized(), 1.0f}, {}, Vector3{ 0.5f, 0.0f, 1.0f}.normalized(), {1.0f, 0.5f}, 0xff0080_rgbf, 26234}, {{-0.75f, 0.75f, -0.35f}, Vector4{Vector3{1.0f, -0.5f, 0.0f}.normalized(), -1.0f}, {}, Vector3{-0.5f, 0.5f, 1.0f}.normalized(), {0.0f, 1.0f}, 0x00ffff_rgbf, 26234}, {{ 0.0f, 0.75f, -0.25f}, Vector4{Vector3{1.0f, -0.5f, 0.0f}.normalized(), -1.0f}, {}, Vector3{ 0.0f, 0.5f, 1.0f}.normalized(), {0.5f, 1.0f}, 0x8080ff_rgbf, 26234}, {{ 0.75f, 0.75f, -0.35f}, Vector4{Vector3{1.0f, -0.5f, 0.0f}.normalized(), -1.0f}, {}, Vector3{ 0.5f, 0.5f, 1.0f}.normalized(), {1.0f, 1.0f}, 0xff00ff_rgbf, 26234} }; auto vertices = Containers::stridedArrayView(vertexData); /* Calculate bitangents from normal+tangent */ for(Vertex& i: vertexData) i.bitangent = Math::cross(i.normal, i.tangent.xyz())*i.tangent.w(); Containers::Array attributeData; arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::Position, vertices.slice(&Vertex::position)); if(data.flags & Flag::Tangents || data.flags & Flag::BitangentsFromTangents) arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::Tangent, vertices.slice(&Vertex::tangent)); if(data.flags & Flag::Bitangents) arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::Bitangent, vertices.slice(&Vertex::bitangent)); if(data.flags & Flag::Normals) arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::Normal, vertices.slice(&Vertex::normal)); if(data.flags & Flag::TextureCoordinates2D) arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::TextureCoordinates, vertices.slice(&Vertex::textureCoordinates)); if(data.flags & Flag::Colors) arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::Color, vertices.slice(&Vertex::color)); if(data.flags & Flag::ObjectId) arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::ObjectId, vertices.slice(&Vertex::objectId)); const UnsignedByte indexData[]{ 66, 78, 23, /* offset */ 0, 1, 4, 0, 4, 3, 1, 2, 5, 1, 5, 4, 3, 4, 7, 3, 7, 6, 4, 5, 8, 4, 8, 7 }; Trade::MeshIndexData indices; if(data.indexType) indices = Trade::MeshIndexData{*data.indexType, Containers::stridedArrayView(Containers::arrayView(indexData).exceptPrefix(3))}; else indices = Trade::MeshIndexData{Containers::arrayView(indexData).exceptPrefix(3)}; Trade::MeshData meshData{MeshPrimitive::Triangles, {}, indexData, indices, {}, vertexData, Utility::move(attributeData)}; /* Duplicate everything if data is non-indexed */ if(data.flags & Flag::NonIndexed) { meshData = duplicate(meshData); /* Update object IDs in the bottom half */ if(data.flags & Flag::ObjectId) { auto objectIds = meshData.mutableAttribute(Trade::MeshAttribute::ObjectId); for(std::size_t i = 0; i != meshData.vertexCount()/2; ++i) objectIds[i] = 13562; } } MAGNUM_VERIFY_NO_GL_ERROR(); CompileFlags flags; if(data.flags & Flag::GeneratedFlatNormals) flags |= CompileFlag::GenerateFlatNormals; if(data.flags & Flag::GeneratedSmoothNormals) flags |= CompileFlag::GenerateSmoothNormals; #ifdef MAGNUM_BUILD_DEPRECATED CORRADE_IGNORE_DEPRECATED_PUSH /** @todo remove once MeshDataXD is gone */ #endif GL::Mesh mesh = compile(T{Utility::move(meshData)}, flags); #ifdef MAGNUM_BUILD_DEPRECATED CORRADE_IGNORE_DEPRECATED_POP #endif MAGNUM_VERIFY_NO_GL_ERROR(); if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) || !(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); Matrix4 projection = Matrix4::perspectiveProjection(45.0_degf, 1.0f, 0.1f, 10.0f); Matrix4 transformation = Matrix4::translation(Vector3::zAxis(-2.0f)); /* Check with the flat shader, it should always work */ { _framebuffer.clear(GL::FramebufferClear::Color); _flat3D .setTransformationProjectionMatrix(projection*transformation) .setColor(0x6633ff_rgbf) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/flat3D.tga"), (DebugTools::CompareImageToFile{_manager})); } /* Check with the phong shader, if we have normals (but not flat generated) */ if(data.flags & Flag::Normals && !(data.flags & Flag::GeneratedFlatNormals)) { _framebuffer.clear(GL::FramebufferClear::Color); _phong .setDiffuseColor(0x33ff66_rgbf) .setTransformationMatrix(transformation) .setNormalMatrix(transformation.normalMatrix()) .setProjectionMatrix(projection) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/phong.tga"), /* SwiftShader has some minor off-by-one precision differences, NVidia as well */ (DebugTools::CompareImageToFile{_manager, 0.5f, 0.029f})); } /* Check generated flat / smooth normals with the phong shader. If smooth normals are requested but the mesh is not indexed, it should behave the same as flat normals. */ if(data.flags & Flag::GeneratedFlatNormals || (data.flags & Flag::GeneratedSmoothNormals && data.flags & Flag::NonIndexed)) { _framebuffer.clear(GL::FramebufferClear::Color); _phong .setDiffuseColor(0x33ff66_rgbf) .setTransformationMatrix(transformation) .setNormalMatrix(transformation.normalMatrix()) .setProjectionMatrix(projection) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/phong-flat.tga"), /* SwiftShader has some minor off-by-one precision differences, NVidia as well */ (DebugTools::CompareImageToFile{_manager, 0.5f, 0.020f})); } else if(data.flags & Flag::GeneratedSmoothNormals) { _framebuffer.clear(GL::FramebufferClear::Color); _phong .setDiffuseColor(0x33ff66_rgbf) .setTransformationMatrix(transformation) .setNormalMatrix(transformation.normalMatrix()) .setProjectionMatrix(projection) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/phong-smooth.tga"), /* SwiftShader has some minor off-by-one precision differences, NVidia as well */ (DebugTools::CompareImageToFile{_manager, 0.5f, 0.037f})); } /* Check with the colored shader, if we have colors */ if(data.flags & Flag::Colors) { _framebuffer.clear(GL::FramebufferClear::Color); _color3D .setTransformationProjectionMatrix(projection*transformation) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/color3D.tga"), /* SwiftShader has some minor off-by-one precision differences */ (DebugTools::CompareImageToFile{_manager, 0.5f, 0.0162f})); } /* Check with the textured shader, if we have texture coords */ if(data.flags & Flag::TextureCoordinates2D) { _framebuffer.clear(GL::FramebufferClear::Color); _flatTextured3D .setTransformationProjectionMatrix(projection*transformation) .bindTexture(_texture) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/textured3D.tga"), /* SwiftShader has some minor off-by-one precision differences, llvmpipe as well */ (DebugTools::CompareImageToFile{_manager, 2.0f, 0.256f})); } #ifndef MAGNUM_TARGET_GLES2 /* Check object ID rendering, if we have per-vertex object ID */ if(data.flags & Flag::ObjectId) { _framebuffer.clearColor(1, Vector4ui{27}); _flatObjectId3D .setTransformationProjectionMatrix(projection*transformation) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); /* Object ID -- no need to verify the whole image, just check that pixels on known places have expected values. SwiftShader insists that the read format has to be 32bit, so the renderbuffer format is that too to make it the same (ES3 Mesa complains if these don't match). */ _framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{1}); CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete); Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::R32UI}); MAGNUM_VERIFY_NO_GL_ERROR(); /* Outside of the object, cleared to 27 */ CORRADE_COMPARE(image.pixels()[2][2], 27); /* Inside of the object, bottom and top half should be different */ CORRADE_COMPARE(image.pixels()[11][18], 13562); CORRADE_COMPARE(image.pixels()[19][15], 26234); } #endif /* Check with the mesh visualizer shader for TBN direction. This has to be last, as it gets skipped on WebGL / ES2. */ if(data.flags >= (Flag::Tangents|Flag::Bitangents|Flag::Normals) || data.flags >= (Flag::Tangents|Flag::BitangentsFromTangents|Flag::Normals)) { #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL) #ifndef MAGNUM_TARGET_GLES if(!GL::Context::current().isExtensionSupported()) CORRADE_SKIP(GL::Extensions::ARB::geometry_shader4::string() << "is not supported."); #else if(!GL::Context::current().isExtensionSupported()) CORRADE_SKIP(GL::Extensions::EXT::geometry_shader::string() << "is not supported."); #endif _framebuffer.clear(GL::FramebufferClear::Color); if(data.flags >= (Flag::Tangents|Flag::Bitangents|Flag::Normals)) _meshVisualizer3D .setTransformationMatrix(transformation) .setProjectionMatrix(projection) .setViewportSize({32, 32}) .setSmoothness(0.0f) /* To avoid perspective artifacts */ .draw(mesh); else if(data.flags >= (Flag::Tangents|Flag::BitangentsFromTangents|Flag::Normals)) _meshVisualizerBitangentsFromTangents3D .setTransformationMatrix(transformation) .setProjectionMatrix(projection) .setViewportSize({32, 32}) .setSmoothness(0.0f) /* To avoid perspective artifacts */ .draw(mesh); else CORRADE_VERIFY(false); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/tbn.tga"), /* SwiftShader has some minor off-by-one precision differences */ (DebugTools::CompareImageToFile{_manager, 1.0f, 0.0948f})); #else CORRADE_SKIP("Geometry shaders not available on ES2 or WebGL."); #endif } } /* Can't be inline because MSVC 2015 doesn't like anonymous bitfields in local structs */ struct PackedVertex { Vector3s position; Vector3s normal; Vector2us textureCoordinates; Color4ub color; UnsignedShort objectId; UnsignedShort:16; }; void CompileGLTest::packedAttributes() { /* Same as above, except that the middle row of indices is duplicated to make it possible to have different object IDs for the bottom and top row while still be able to test non-default index type as well. 9----10----11 | /| /| | / | / | |/ |/ | 6-----7-----8 3-----4-----5 | /| /| | / | / | |/ |/ | 0-----1-----2 */ const PackedVertex vertexData[]{ {Math::pack(Vector3{-0.75f, -0.75f, -0.35f}), Math::pack(Vector3{-0.5f, -0.5f, 1.0f}.normalized()), Math::pack(Vector2{0.0f, 0.0f}), 0x00ff00_rgb, 13562}, {Math::pack(Vector3{ 0.00f, -0.75f, -0.25f}), Math::pack(Vector3{ 0.0f, -0.5f, 1.0f}.normalized()), Math::pack(Vector2{0.5f, 0.0f}), 0x808000_rgb, 13562}, {Math::pack(Vector3{ 0.75f, -0.75f, -0.35f}), Math::pack(Vector3{ 0.5f, -0.5f, 1.0f}.normalized()), Math::pack(Vector2{1.0f, 0.0f}), 0xff0000_rgb, 13562}, {Math::pack(Vector3{-0.75f, 0.00f, -0.25f}), Math::pack(Vector3{-0.5f, 0.0f, 1.0f}.normalized()), Math::pack(Vector2{0.0f, 0.5f}), 0x00ff80_rgb, 13562}, {Math::pack(Vector3{ 0.00f, 0.00f, 0.00f}), Math::pack(Vector3{ 0.0f, 0.0f, 1.0f}.normalized()), Math::pack(Vector2{0.5f, 0.5f}), 0x808080_rgb, 13562}, {Math::pack(Vector3{ 0.75f, 0.00f, -0.25f}), Math::pack(Vector3{ 0.5f, 0.0f, 1.0f}.normalized()), Math::pack(Vector2{1.0f, 0.5f}), 0xff0080_rgb, 13562}, {Math::pack(Vector3{-0.75f, 0.00f, -0.25f}), Math::pack(Vector3{-0.5f, 0.0f, 1.0f}.normalized()), Math::pack(Vector2{0.0f, 0.5f}), 0x00ff80_rgb, 26234}, {Math::pack(Vector3{ 0.00f, 0.00f, 0.00f}), Math::pack(Vector3{ 0.0f, 0.0f, 1.0f}.normalized()), Math::pack(Vector2{0.5f, 0.5f}), 0x808080_rgb, 26234}, {Math::pack(Vector3{ 0.75f, 0.00f, -0.25f}), Math::pack(Vector3{ 0.5f, 0.0f, 1.0f}.normalized()), Math::pack(Vector2{1.0f, 0.5f}), 0xff0080_rgb, 26234}, {Math::pack(Vector3{-0.75f, 0.75f, -0.35f}), Math::pack(Vector3{-0.5f, 0.5f, 1.0f}.normalized()), Math::pack(Vector2{0.0f, 1.0f}), 0x00ffff_rgb, 26234}, {Math::pack(Vector3{ 0.0f, 0.75f, -0.25f}), Math::pack(Vector3{ 0.0f, 0.5f, 1.0f}.normalized()), Math::pack(Vector2{0.5f, 1.0f}), 0x8080ff_rgb, 26234}, {Math::pack(Vector3{ 0.75f, 0.75f, -0.35f}), Math::pack(Vector3{ 0.5f, 0.5f, 1.0f}.normalized()), Math::pack(Vector2{1.0f, 1.0f}), 0xff00ff_rgb, 26234} }; static_assert(sizeof(PackedVertex) % 4 == 0, "the vertex is not 4-byte aligned and that's bad"); auto vertices = Containers::stridedArrayView(vertexData); const UnsignedByte indexData[]{ 0, 1, 4, 0, 4, 3, 1, 2, 5, 1, 5, 4, 6, 7, 10, 6, 10, 9, 7, 8, 11, 7, 11, 10 }; Trade::MeshData meshData{MeshPrimitive::Triangles, {}, indexData, Trade::MeshIndexData{indexData}, {}, vertexData, { Trade::MeshAttributeData{Trade::MeshAttribute::Position, VertexFormat::Vector3sNormalized, vertices.slice(&PackedVertex::position)}, Trade::MeshAttributeData{Trade::MeshAttribute::Normal, VertexFormat::Vector3sNormalized, vertices.slice(&PackedVertex::normal)}, Trade::MeshAttributeData{Trade::MeshAttribute::TextureCoordinates, VertexFormat::Vector2usNormalized, vertices.slice(&PackedVertex::textureCoordinates)}, Trade::MeshAttributeData{Trade::MeshAttribute::Color, /* It should figure out the type itself here */ vertices.slice(&PackedVertex::color)}, #ifndef MAGNUM_TARGET_GLES2 Trade::MeshAttributeData{Trade::MeshAttribute::ObjectId, vertices.slice(&PackedVertex::objectId)} #endif }}; GL::Mesh mesh = compile(meshData); MAGNUM_VERIFY_NO_GL_ERROR(); if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) || !(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); Matrix4 projection = Matrix4::perspectiveProjection(45.0_degf, 1.0f, 0.1f, 10.0f); Matrix4 transformation = Matrix4::translation(Vector3::zAxis(-2.0f)); /* In all checks below, the rendering should be practically 1:1 as above with full-blown attribute types */ /* Check positions and normals */ _framebuffer.clear(GL::FramebufferClear::Color); _phong .setDiffuseColor(0x33ff66_rgbf) .setTransformationMatrix(transformation) .setNormalMatrix(transformation.normalMatrix()) .setProjectionMatrix(projection) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/phong.tga"), /* SwiftShader has some minor off-by-one precision differences. NVidia as well, more on ES2 */ (DebugTools::CompareImageToFile{_manager, 0.5f, 0.029f})); /* Check colors */ _framebuffer.clear(GL::FramebufferClear::Color); _color3D .setTransformationProjectionMatrix(projection*transformation) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/color3D.tga"), /* SwiftShader has some minor off-by-one precision differences */ (DebugTools::CompareImageToFile{_manager, 0.5f, 0.0162f})); /* Check texture coordinates */ _framebuffer.clear(GL::FramebufferClear::Color); _flatTextured3D .setTransformationProjectionMatrix(projection*transformation) .bindTexture(_texture) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/textured3D.tga"), /* SwiftShader has some minor off-by-one precision differences, llvmpipe more */ (DebugTools::CompareImageToFile{_manager, 2.0f, 0.259f})); #ifndef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_GLES if(GL::Context::current().isExtensionSupported()) #endif { _framebuffer.clearColor(1, Vector4ui{27}); _flatObjectId3D .setTransformationProjectionMatrix(projection*transformation) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); /* Object ID -- no need to verify the whole image, just check that pixels on known places have expected values. SwiftShader insists that the read format has to be 32bit, so the renderbuffer format is that too to make it the same (ES3 Mesa complains if these don't match). */ _framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{1}); CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete); Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::R32UI}); MAGNUM_VERIFY_NO_GL_ERROR(); /* Outside of the object, cleared to 27 */ CORRADE_COMPARE(image.pixels()[2][2], 27); /* Inside of the object, bottom and top half should be different */ CORRADE_COMPARE(image.pixels()[11][18], 13562); CORRADE_COMPARE(image.pixels()[19][15], 26234); } #endif } #ifndef MAGNUM_TARGET_GLES2 void CompileGLTest::skinning() { auto&& data = SkinningData[testCaseInstanceId()]; setTestCaseDescription(data.name); /* Same as in FlatGLTest/PhongGLTest/MeshVisualizerGLTest, just padded with two dummy values at the beginning and at the end */ struct Vertex { Vector2 position; UnsignedInt jointIds[7]; Float weights[7]; } vertexData[]{ /* Top right corner gets moved to the right and up, top left just up, bottom right just right, bottom left corner gets slightly scaled. 3--1 | /| |/ | 2--0 */ {{ 1.0f, -1.0f}, {0, 0, 0, 2, 0, 0, 0}, {0.0f, 0.0f, 1.0f, 50.0f, 0.5f, 0.0f, 0.0f}}, {{ 1.0f, 1.0f}, {0, 0, 1, 0, 0, 0, 0}, {0.0f, 0.0f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f}}, {{-1.0f, -1.0f}, {0, 0, 3, 4, 4, 0, 0}, {0.0f, 0.0f, 0.5f, 0.25f, 0.25f, 0.0f, 0.0f}}, {{-1.0f, 1.0f}, {0, 0, 1, 0, 4, 0, 0}, {0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, }; static_assert(sizeof(Vertex) == SkinningDataStride, ""); auto vertices = Containers::stridedArrayView(vertexData); Matrix3 jointMatrices[]{ Matrix3::translation(Vector2::xAxis(0.5f)), Matrix3::translation(Vector2::yAxis(0.5f)), Matrix3{Math::ZeroInit}, Matrix3::scaling(Vector2{2.0f}), Matrix3{Math::IdentityInit}, }; Containers::Array attributeData; arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::Position, vertices.slice(&Vertex::position)); arrayAppend(attributeData, data.attributes); Trade::MeshData meshData{MeshPrimitive::TriangleStrip, {}, vertexData, Utility::move(attributeData)}; Containers::Pair jointCount = compiledPerVertexJointCount(meshData); CORRADE_COMPARE(jointCount.first(), data.expectedJointCount); CORRADE_COMPARE(jointCount.second(), data.expectedSecondaryJointCount); GL::Mesh mesh{NoCreate}; Containers::String out; { Warning redirectWarning{&out}; mesh = compile(meshData); } CORRADE_COMPARE(out, data.expectedMessage); MAGNUM_VERIFY_NO_GL_ERROR(); if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) || !(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); _framebuffer.clear(GL::FramebufferClear::Color); Shaders::FlatGL2D shader{Shaders::FlatGL2D::Configuration{} .setJointCount(Containers::arraySize(jointMatrices), jointCount.first(), jointCount.second())}; shader.setJointMatrices(jointMatrices) .setTransformationProjectionMatrix(Matrix3::scaling(Vector2{0.5f})) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/skinning.tga"), (DebugTools::CompareImageToFile{_manager})); } void CompileGLTest::skinningPackedAttributes() { /* Same as skinning(), just with the attributes packed, and packed differently for each set; and using a 3D shader */ struct Vertex { Vector2 position; UnsignedShort jointIds[4]; UnsignedByte secondaryJointIds[3]; Float weights[4]; Half secondaryWeights[3]; } vertexData[]{ {{ 1.0f, -1.0f}, {0, 0, 0, 2}, {0, 0, 0}, {0.0f, 0.0f, 1.0f, 50.0f}, { 0.5_h, 0.0_h, 0.0_h}}, {{ 1.0f, 1.0f}, {0, 0, 1, 0}, {0, 0, 0}, {0.0f, 0.0f, 0.5f, 0.5f}, { 0.0_h, 0.0_h, 0.0_h}}, {{-1.0f, -1.0f}, {0, 0, 3, 4}, {4, 0, 0}, {0.0f, 0.0f, 0.5f, 0.25f}, {0.25_h, 0.0_h, 0.0_h}}, {{-1.0f, 1.0f}, {0, 0, 1, 0}, {4, 0, 0}, {0.0f, 0.0f, 1.0f, 0.0f}, { 0.0_h, 0.0_h, 0.0_h}}, }; auto vertices = Containers::stridedArrayView(vertexData); Matrix4 jointMatrices[]{ Matrix4::translation(Vector3::xAxis(0.5f)), Matrix4::translation(Vector3::yAxis(0.5f)), Matrix4{Math::ZeroInit}, Matrix4::scaling(Vector3{2.0f}), Matrix4{Math::IdentityInit}, }; Trade::MeshData meshData{MeshPrimitive::TriangleStrip, {}, vertexData, { Trade::MeshAttributeData{Trade::MeshAttribute::Position, vertices.slice(&Vertex::position)}, Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedShort, vertices.slice(&Vertex::jointIds), 4}, Trade::MeshAttributeData{Trade::MeshAttribute::JointIds, VertexFormat::UnsignedByte, vertices.slice(&Vertex::secondaryJointIds), 3}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Float, vertices.slice(&Vertex::weights), 4}, Trade::MeshAttributeData{Trade::MeshAttribute::Weights, VertexFormat::Half, vertices.slice(&Vertex::secondaryWeights), 3}, }}; GL::Mesh mesh = compile(meshData); MAGNUM_VERIFY_NO_GL_ERROR(); if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) || !(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); _framebuffer.clear(GL::FramebufferClear::Color); Shaders::FlatGL3D shader{Shaders::FlatGL3D::Configuration{} .setJointCount(Containers::arraySize(jointMatrices), 4, 3)}; shader.setJointMatrices(jointMatrices) .setTransformationProjectionMatrix(Matrix4::scaling(Vector3{0.5f})) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/skinning.tga"), (DebugTools::CompareImageToFile{_manager})); } #endif void CompileGLTest::conflictingAttributes() { auto&& data = ConflictingAttributesData[testCaseInstanceId()]; setTestCaseDescription(data.name); struct Vertex { Vector2 position; Vector2 textureCoordinates1, textureCoordinates2; UnsignedInt objectId; Vector3 bitangent; } vertexData[]{ {{-0.75f, -0.75f}, {0.0f, 0.0f}, { 0.0f, 0.0f}, 26234, {}}, {{ 0.00f, -0.75f}, {0.5f, 0.0f}, { 5.0f, 0.0f}, 26234, {}}, {{ 0.75f, -0.75f}, {1.0f, 0.0f}, {10.0f, 0.0f}, 26234, {}}, {{-0.75f, 0.00f}, {0.0f, 0.5f}, { 0.0f, 5.0f}, 26234, {}}, {{ 0.00f, 0.00f}, {0.5f, 0.5f}, { 5.0f, 5.0f}, 26234, {}}, {{ 0.75f, 0.00f}, {1.0f, 0.5f}, {10.0f, 5.0f}, 26234, {}}, {{-0.75f, 0.75f}, {0.0f, 1.0f}, { 0.0f, 10.0f}, 26234, {}}, {{ 0.0f, 0.75f}, {0.5f, 1.0f}, { 5.0f, 10.0f}, 26234, {}}, {{ 0.75f, 0.75f}, {1.0f, 1.0f}, {10.0f, 10.0f}, 26234, {}} }; auto vertices = Containers::stridedArrayView(vertexData); const UnsignedInt indexData[]{ 0, 1, 4, 0, 4, 3, 1, 2, 5, 1, 5, 4, 3, 4, 7, 3, 7, 6, 4, 5, 8, 4, 8, 7 }; Containers::Array attributeData; arrayAppend(attributeData, InPlaceInit, Trade::MeshAttribute::Position, vertices.slice(&Vertex::position)); arrayAppend(attributeData, data.attributes); Trade::MeshData meshData{MeshPrimitive::Triangles, {}, indexData, Trade::MeshIndexData{indexData}, {}, vertexData, Utility::move(attributeData)}; GL::Mesh mesh{NoCreate}; Containers::String out; { Warning redirectWarning{&out}; mesh = compile(meshData); } MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE(out, Utility::format("MeshTools::compile(): {}\n", data.expectedMessage)); if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) || !(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); _framebuffer.clear(GL::FramebufferClear::Color); #ifndef MAGNUM_TARGET_GLES2 if(data.flags & Flag::ObjectId) _framebuffer.clearColor(1, Vector4ui{27}); #endif if(data.flags & Flag::TextureCoordinates2D) _flatTextured2D .bindTexture(_texture) .draw(mesh); #ifndef MAGNUM_TARGET_GLES2 else if(data.flags & Flag::ObjectId) _flatObjectId2D .setColor(0xff3366_rgbf) .draw(mesh); #endif else _flat2D .setColor(0xff3366_rgbf) .draw(mesh); /* The output should be the same as in the textured case of twoDimensions() -- i.e., the second texture coordinate set not affecting anything */ MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join({MESHTOOLS_TEST_DIR, "CompileTestFiles", data.expected}), /* SwiftShader has some minor off-by-one precision differences, llvmpipe as well */ (DebugTools::CompareImageToFile{_manager, 1.75f, 0.22f})); #ifndef MAGNUM_TARGET_GLES2 if(data.flags & Flag::ObjectId) { _framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{1}); CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete); Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::R32UI}); MAGNUM_VERIFY_NO_GL_ERROR(); /* Outside of the object, cleared to 27 */ CORRADE_COMPARE(image.pixels()[2][2], 27); CORRADE_COMPARE(image.pixels()[11][18], data.expectedObjectId); } #endif } void CompileGLTest::unsupportedIndexStride() { CORRADE_SKIP_IF_NO_ASSERT(); UnsignedShort indices[2]{}; Trade::MeshData data{MeshPrimitive::Points, {}, indices, Trade::MeshIndexData{Containers::stridedArrayView(indices).every(2)}, 1}; Containers::String out; Error redirectError{&out}; compile(data); CORRADE_COMPARE(out, "MeshTools::compile(): MeshIndexType::UnsignedShort with stride of 4 bytes isn't supported by OpenGL\n"); } void CompileGLTest::morphTargetAttributes() { auto&& instanceData = CustomAttributeWarningData[testCaseInstanceId()]; setTestCaseDescription(instanceData.name); Vector3 vertexData[2]{}; Trade::MeshData data{MeshPrimitive::Triangles, {}, vertexData, { Trade::MeshAttributeData{Trade::MeshAttribute::Position, Containers::arrayView(vertexData)}, Trade::MeshAttributeData{Trade::MeshAttribute::Color, Containers::arrayView(vertexData), 37}, Trade::MeshAttributeData{Trade::MeshAttribute::Position, Containers::arrayView(vertexData), 26}, }}; Containers::String out; Warning redirectError{&out}; if(instanceData.flags) compile(data, instanceData.flags); else compile(data); CORRADE_COMPARE(out, instanceData.flags ? "" : "MeshTools::compile(): ignoring 2 morph target attributes\n"); } void CompileGLTest::customAttribute() { auto&& instanceData = CustomAttributeWarningData[testCaseInstanceId()]; setTestCaseDescription(instanceData.name); Trade::MeshData data{MeshPrimitive::Triangles, nullptr, { Trade::MeshAttributeData{Trade::meshAttributeCustom(115), VertexFormat::Short, nullptr} }}; Containers::String out; Warning redirectError{&out}; if(instanceData.flags) compile(data, instanceData.flags); else compile(data); CORRADE_COMPARE(out, instanceData.flags ? "" : "MeshTools::compile(): ignoring unknown/unsupported attribute Trade::MeshAttribute::Custom(115)\n"); } void CompileGLTest::unsupportedAttribute() { auto&& instanceData = CustomAttributeWarningData[testCaseInstanceId()]; setTestCaseDescription(instanceData.name); #ifndef MAGNUM_TARGET_GLES2 CORRADE_SKIP("All attributes are supported on ES3+."); #else Trade::MeshData data{MeshPrimitive::Triangles, nullptr, { Trade::MeshAttributeData{Trade::MeshAttribute::ObjectId, VertexFormat::UnsignedByte, nullptr} }}; Containers::String out; Warning redirectError{&out}; if(instanceData.flags) compile(data, instanceData.flags); else compile(data); /* Warns always, regardless of the flag */ CORRADE_COMPARE(out, "MeshTools::compile(): ignoring unknown/unsupported attribute Trade::MeshAttribute::ObjectId\n"); #endif } void CompileGLTest::unsupportedAttributeStride() { CORRADE_SKIP_IF_NO_ASSERT(); Vector3 data[2]{}; Trade::MeshData zero{MeshPrimitive::Points, {}, data, { Trade::MeshAttributeData{Trade::MeshAttribute::Position, Containers::stridedArrayView(data, 1).broadcasted<0>(2)} }}; Trade::MeshData negative{MeshPrimitive::Points, {}, data, { Trade::MeshAttributeData{Trade::MeshAttribute::Normal, Containers::stridedArrayView(data).flipped<0>()} }}; Containers::String out; Error redirectError{&out}; compile(zero); compile(negative); CORRADE_COMPARE(out, "MeshTools::compile(): Trade::MeshAttribute::Position stride of 0 bytes isn't supported by OpenGL\n" "MeshTools::compile(): Trade::MeshAttribute::Normal stride of -12 bytes isn't supported by OpenGL\n"); } void CompileGLTest::implementationSpecificAttributeFormat() { auto&& instanceData = CustomAttributeWarningData[testCaseInstanceId()]; setTestCaseDescription(instanceData.name); Trade::MeshData data{MeshPrimitive::Triangles, nullptr, { Trade::MeshAttributeData{Trade::MeshAttribute::Position, vertexFormatWrap(0xdead), nullptr} }}; Containers::String out; Warning redirectError{&out}; if(instanceData.flags) compile(data, instanceData.flags); else compile(data); CORRADE_COMPARE(out, instanceData.flags ? "" : "MeshTools::compile(): ignoring attribute Trade::MeshAttribute::Position with an implementation-specific format 0xdead\n"); } void CompileGLTest::generateNormalsNoPosition() { CORRADE_SKIP_IF_NO_ASSERT(); Trade::MeshData data{MeshPrimitive::Triangles, 1}; Containers::String out; Error redirectError{&out}; compile(data, CompileFlag::GenerateFlatNormals); CORRADE_COMPARE(out, "MeshTools::compile(): the mesh has no positions, can't generate normals\n"); } void CompileGLTest::generateNormals2DPosition() { CORRADE_SKIP_IF_NO_ASSERT(); Trade::MeshData data{MeshPrimitive::Triangles, nullptr, { Trade::MeshAttributeData{Trade::MeshAttribute::Position, VertexFormat::Vector2, nullptr} }}; Containers::String out; Error redirectError{&out}; compile(data, CompileFlag::GenerateFlatNormals); CORRADE_COMPARE(out, "MeshTools::compile(): can't generate normals for VertexFormat::Vector2 positions\n"); } void CompileGLTest::generateNormalsNoFloats() { CORRADE_SKIP_IF_NO_ASSERT(); Trade::MeshData data{MeshPrimitive::Triangles, nullptr, { Trade::MeshAttributeData{Trade::MeshAttribute::Position, VertexFormat::Vector3, nullptr}, Trade::MeshAttributeData{Trade::MeshAttribute::Normal, VertexFormat::Vector3h, nullptr}, }}; Containers::String out; Error redirectError{&out}; compile(data, CompileFlag::GenerateFlatNormals); CORRADE_COMPARE(out, "MeshTools::compile(): can't generate normals into VertexFormat::Vector3h\n"); } void CompileGLTest::externalBuffers() { auto&& data = DataExternal[testCaseInstanceId()]; setTestCaseDescription(data.name); /* 6-----7-----8 | /| /| | / | / | |/ |/ | 3-----4-----5 | /| /| | / | / | |/ |/ | 0-----1-----2 */ Vector2 positions[] { {-0.75f, -0.75f}, { 0.00f, -0.75f}, { 0.75f, -0.75f}, {-0.75f, 0.00f}, { 0.00f, 0.00f}, { 0.75f, 0.00f}, {-0.75f, 0.75f}, { 0.0f, 0.75f}, { 0.75f, 0.75f} }; const UnsignedShort indexData[]{ 0, 1, 4, 0, 4, 3, 1, 2, 5, 1, 5, 4, 3, 4, 7, 3, 7, 6, 4, 5, 8, 4, 8, 7 }; Trade::MeshData meshData{MeshPrimitive::Triangles, {}, indexData, Trade::MeshIndexData{indexData}, {}, positions, { Trade::MeshAttributeData{Trade::MeshAttribute::Position, Containers::arrayView(positions)} }}; /* Duplicate everything if data is non-indexed */ if(!data.indexed) meshData = duplicate(meshData); GL::Buffer indices{NoCreate}; if(meshData.isIndexed()) { indices = GL::Buffer{GL::Buffer::TargetHint::ElementArray}; indices.setData(meshData.indexData()); } GL::Buffer vertices{GL::Buffer::TargetHint::Array}; vertices.setData(meshData.vertexData()); MAGNUM_VERIFY_NO_GL_ERROR(); GL::Mesh mesh{NoCreate}; if(data.moveIndices && data.moveVertices) mesh = compile(meshData, Utility::move(indices), Utility::move(vertices)); else if(data.moveIndices && !data.moveVertices) mesh = compile(meshData, Utility::move(indices), vertices); else if(!data.moveIndices && data.moveVertices) mesh = compile(meshData, indices, Utility::move(vertices)); else mesh = compile(meshData, indices, vertices); MAGNUM_VERIFY_NO_GL_ERROR(); if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) || !(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded)) CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found."); _framebuffer.clear(GL::FramebufferClear::Color); _flat2D .setColor(0xff3366_rgbf) .draw(mesh); MAGNUM_VERIFY_NO_GL_ERROR(); CORRADE_COMPARE_WITH( _framebuffer.read({{}, {32, 32}}, {PixelFormat::RGBA8Unorm}), Utility::Path::join(MESHTOOLS_TEST_DIR, "CompileTestFiles/flat2D.tga"), (DebugTools::CompareImageToFile{_manager})); } void CompileGLTest::externalBuffersInvalid() { CORRADE_SKIP_IF_NO_ASSERT(); Trade::MeshData data{MeshPrimitive::Triangles, 5}; Trade::MeshData indexedData{MeshPrimitive::Triangles, nullptr, Trade::MeshIndexData{MeshIndexType::UnsignedInt, nullptr}, {}}; compile(data, GL::Buffer{NoCreate}, GL::Buffer{}); /* this is okay */ Containers::String out; Error redirectError{&out}; compile(data, GL::Buffer{NoCreate}, GL::Buffer{NoCreate}); compile(indexedData, GL::Buffer{NoCreate}, GL::Buffer{}); CORRADE_COMPARE(out, "MeshTools::compile(): invalid external buffer(s)\n" "MeshTools::compile(): invalid external buffer(s)\n"); } }}}} CORRADE_TEST_MAIN(Magnum::MeshTools::Test::CompileGLTest)