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

Port away from deprecated Shaders functionality. 

What's especially nice is that the code snippets no longer need to
describe that there's "2 lights, 3 materials and 5 draws" because now
it's self-documenting.
pull/582/merge
Vladimír Vondruš 4 years ago
parent
c5abcf5140
commit
744353b6cd
11 changed files with 569 additions and 250 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      doc/generated/primitives.cpp
  2. 22
      doc/generated/shaders.cpp
  3. 111
      doc/snippets/MagnumShaders-gl.cpp
  4. 28
      src/Magnum/MeshTools/Test/CompileGLTest.cpp
  5. 64
      src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp
  6. 113
      src/Magnum/Shaders/Test/FlatGLTest.cpp
  7. 199
      src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp
  8. 135
      src/Magnum/Shaders/Test/PhongGLTest.cpp
  9. 36
      src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp
  10. 62
      src/Magnum/Shaders/Test/VectorGLTest.cpp
  11. 43
      src/Magnum/Shaders/Test/VertexColorGLTest.cpp

6
doc/generated/primitives.cpp
Unescape View File

@ -278,7 +278,8 @@ int PrimitiveVisualizer::exec() {
}
}
Shaders::MeshVisualizerGL2D wireframe2D{Shaders::MeshVisualizerGL2D::Flag::Wireframe};
Shaders::MeshVisualizerGL2D wireframe2D{Shaders::MeshVisualizerGL2D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL2D::Flag::Wireframe)};
wireframe2D.setColor(0x00000000_srgbaf)
.setWireframeColor(OutlineColor)
.setWireframeWidth(2.0f)
@ -309,7 +310,8 @@ int PrimitiveVisualizer::exec() {
}
}
Shaders::MeshVisualizerGL3D wireframe3D{Shaders::MeshVisualizerGL3D::Flag::Wireframe};
Shaders::MeshVisualizerGL3D wireframe3D{Shaders::MeshVisualizerGL3D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe)};
wireframe3D.setColor(0x00000000_srgbaf)
.setWireframeColor(OutlineColor)
.setWireframeWidth(2.0f)

22
doc/generated/shaders.cpp
Unescape View File

@ -180,7 +180,9 @@ std::string ShaderVisualizer::meshVisualizer2D() {
Matrix3::projection(Vector2{3.0f})*
Matrix3::rotation(13.7_degf);
Shaders::MeshVisualizerGL2D{Shaders::MeshVisualizerGL2D::Flag::Wireframe}
Shaders::MeshVisualizerGL2D shader{Shaders::MeshVisualizerGL2D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL2D::Flag::Wireframe)};
shader
.setColor(BaseColor)
.setWireframeColor(OutlineColor)
.setWireframeWidth(2.0f)
@ -206,7 +208,9 @@ std::string ShaderVisualizer::meshVisualizer2DPrimitiveId() {
.setStorage(1, GL::TextureFormat::SRGB8Alpha8, size)
.setSubImage(0, {}, ImageView2D{PixelFormat::RGB8Srgb, size, map});
Shaders::MeshVisualizerGL2D{Shaders::MeshVisualizerGL2D::Flag::PrimitiveId}
Shaders::MeshVisualizerGL2D shader{Shaders::MeshVisualizerGL2D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL2D::Flag::PrimitiveId)};
shader
.setTransformationProjectionMatrix(projection)
.setColorMapTransformation(1.0f/255.0f, 1.0f/8.0f)
.bindColorMapTexture(colorMapTexture)
@ -220,10 +224,12 @@ std::string ShaderVisualizer::meshVisualizer3D() {
Matrix4::rotationZ(13.7_degf)*
Matrix4::rotationX(-12.6_degf);
Shaders::MeshVisualizerGL3D{Shaders::MeshVisualizerGL3D::Flag::Wireframe|
Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
Shaders::MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
Shaders::MeshVisualizerGL3D::Flag::NormalDirection}
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe|
Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
Shaders::MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
Shaders::MeshVisualizerGL3D::Flag::NormalDirection)};
shader
.setColor(BaseColor)
.setWireframeColor(OutlineColor)
.setWireframeWidth(2.0f)
@ -253,7 +259,9 @@ std::string ShaderVisualizer::meshVisualizer3DPrimitiveId() {
.setStorage(1, GL::TextureFormat::SRGB8Alpha8, size)
.setSubImage(0, {}, ImageView2D{PixelFormat::RGB8Srgb, size, map});
Shaders::MeshVisualizerGL3D{Shaders::MeshVisualizerGL3D::Flag::PrimitiveId}
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL3D::Flag::PrimitiveId)};
shader
.setTransformationMatrix(transformation)
.setProjectionMatrix(Projection)
.setColorMapTransformation(1.0f/255.0f, 1.0f/32.0f)

111
doc/snippets/MagnumShaders-gl.cpp
Unescape View File

@ -145,7 +145,8 @@ drawUniform.setData({
.setNormalMatrix(transformationMatrix.normalMatrix())
});
Shaders::PhongGL shader{Shaders::PhongGL::Flag::UniformBuffers};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::UniformBuffers)};
shader
.bindProjectionBuffer(projectionUniform)
.bindLightBuffer(lightUniform)
@ -191,8 +192,11 @@ drawUniform.setData({
.setMaterialId(0),
});
/* One light, two materials, three draws */
Shaders::PhongGL shader{Shaders::PhongGL::Flag::UniformBuffers, 1, 2, 3};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::UniformBuffers)
.setLightCount(1)
.setMaterialCount(2)
.setDrawCount(3)};
shader
.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
@ -214,8 +218,11 @@ GL::Mesh mesh;
GL::MeshView redConeView{DOXYGEN_ELLIPSIS(mesh)}, yellowCubeView{DOXYGEN_ELLIPSIS(mesh)}, redSphereView{DOXYGEN_ELLIPSIS(mesh)};
DOXYGEN_ELLIPSIS()
/* One light, two materials, three draws; with multidraw enabled */
Shaders::PhongGL shader{Shaders::PhongGL::Flag::MultiDraw, 1, 2, 3};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::MultiDraw)
.setLightCount(1)
.setMaterialCount(2)
.setDrawCount(3)};
shader
DOXYGEN_ELLIPSIS()
.draw({redConeView, yellowCubeView, redSphereView});
@ -253,8 +260,9 @@ sphereInstanced.addVertexBufferInstanced(GL::Buffer{instanceData}, 1, 0,
Shaders::PhongGL::Color3{});
sphereInstanced.setInstanceCount(3);
Shaders::PhongGL shader{Shaders::PhongGL::Flag::InstancedTransformation|
Shaders::PhongGL::Flag::VertexColor};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::InstancedTransformation|
Shaders::PhongGL::Flag::VertexColor)};
shader
.setProjectionMatrix(projectionMatrix)
DOXYGEN_ELLIPSIS()
@ -268,7 +276,8 @@ GL::Mesh mesh;
GL::Texture2D diffuseTexture;
DOXYGEN_ELLIPSIS()
Shaders::PhongGL shader{Shaders::PhongGL::Flag::DiffuseTexture};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::DiffuseTexture)};
shader.bindDiffuseTexture(diffuseTexture)
DOXYGEN_ELLIPSIS()
.draw(mesh);
@ -302,11 +311,13 @@ textureTransformationUniform.setData({
.setLayer(2),
});
Shaders::PhongGL shader{
Shaders::PhongGL::Flag::MultiDraw|
Shaders::PhongGL::Flag::DiffuseTexture|
Shaders::PhongGL::Flag::TextureArrays,
1, 2, 3};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::MultiDraw|
Shaders::PhongGL::Flag::DiffuseTexture|
Shaders::PhongGL::Flag::TextureArrays)
.setLightCount(1)
.setMaterialCount(2)
.setDrawCount(3)};
shader
DOXYGEN_ELLIPSIS()
.bindDiffuseTexture(diffuseTexture)
@ -331,7 +342,8 @@ mesh.addVertexBuffer(vertices, 0,
GL::Mesh mesh;
Matrix4 transformationMatrix, projectionMatrix;
/* [shaders-meshvisualizer] */
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Flag::Wireframe};
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe)};
shader
.setColor(0x2f83cc_rgbf)
.setWireframeColor(0xdcdcdc_rgbf)
@ -347,9 +359,11 @@ shader
Shaders::FlatGL3D::CompileState flatState =
Shaders::FlatGL3D::compile();
Shaders::FlatGL3D::CompileState flatTexturedState =
Shaders::FlatGL3D::compile(Shaders::FlatGL3D::Flag::Textured);
Shaders::FlatGL3D::compile(
Shaders::FlatGL3D::Configuration{}
.setFlags(Shaders::FlatGL3D::Flag::Textured));
Shaders::MeshVisualizerGL3D::CompileState meshVisualizerState =
Shaders::MeshVisualizerGL3D::compile(DOXYGEN_ELLIPSIS(Shaders::MeshVisualizerGL3D::Flag::Wireframe));
Shaders::MeshVisualizerGL3D::compile(DOXYGEN_ELLIPSIS(Shaders::MeshVisualizerGL3D::Configuration{}));
while(!flatState.isLinkFinished() ||
!flatTexturedState.isLinkFinished() ||
@ -428,8 +442,8 @@ drawUniform.setData({
});
Shaders::DistanceFieldVectorGL2D shader{
Shaders::DistanceFieldVectorGL2D::Flag::UniformBuffers
};
Shaders::DistanceFieldVectorGL2D::Configuration{}
.setFlags(Shaders::DistanceFieldVectorGL2D::Flag::UniformBuffers)};
shader
.bindTransformationProjectionBuffer(projectionTransformationUniform)
.bindMaterialBuffer(materialUniform)
@ -498,7 +512,8 @@ mesh.addVertexBuffer(vertices, 0,
Matrix4 transformationMatrix, projectionMatrix;
GL::Texture2D texture;
Shaders::FlatGL3D shader{Shaders::FlatGL3D::Flag::Textured};
Shaders::FlatGL3D shader{Shaders::FlatGL3D::Configuration{}
.setFlags(Shaders::FlatGL3D::Flag::Textured)};
shader.setTransformationProjectionMatrix(projectionMatrix*transformationMatrix)
.bindTexture(texture)
.draw(mesh);
@ -519,7 +534,8 @@ objectId.setStorage(GL::RenderbufferFormat::R16UI, size); // large as needed
framebuffer.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, color)
.attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, objectId);
Shaders::FlatGL3D shader{Shaders::FlatGL3D::Flag::ObjectId};
Shaders::FlatGL3D shader{Shaders::FlatGL3D::Configuration{}
.setFlags(Shaders::FlatGL3D::Flag::ObjectId)};
// ...
@ -581,7 +597,8 @@ drawUniform.setData({
.setMaterialId(0)
});
Shaders::FlatGL3D shader{Shaders::FlatGL3D::Flag::UniformBuffers};
Shaders::FlatGL3D shader{Shaders::FlatGL3D::Configuration{}
.setFlags(Shaders::FlatGL3D::Flag::UniformBuffers)};
shader
.bindTransformationProjectionBuffer(projectionTransformationUniform)
.bindMaterialBuffer(materialUniform)
@ -677,7 +694,8 @@ Matrix4 transformationMatrix = Matrix4::translation(Vector3::zAxis(-5.0f));
Matrix4 projectionMatrix =
Matrix4::perspectiveProjection(35.0_degf, 1.0f, 0.001f, 100.0f);
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Flag::Wireframe};
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe)};
shader.setColor(0x2f83cc_rgbf)
.setWireframeColor(0xdcdcdc_rgbf)
.setViewportSize(Vector2{GL::defaultFramebuffer.viewport().size()})
@ -726,10 +744,10 @@ mesh.addVertexBuffer(vertices, 0,
/* [MeshVisualizerGL3D-usage-tbn2] */
Matrix4 transformationMatrix, projectionMatrix;
Shaders::MeshVisualizerGL3D shader{
Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
Shaders::MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
Shaders::MeshVisualizerGL3D::Flag::NormalDirection};
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
Shaders::MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
Shaders::MeshVisualizerGL3D::Flag::NormalDirection)};
shader.setViewportSize(Vector2{GL::defaultFramebuffer.viewport().size()})
.setTransformationMatrix(transformationMatrix)
.setProjectionMatrix(projectionMatrix)
@ -759,9 +777,9 @@ GL::Mesh mesh;
/* [MeshVisualizerGL3D-usage-no-geom2] */
Matrix4 transformationMatrix, projectionMatrix;
Shaders::MeshVisualizerGL3D shader{
Shaders::MeshVisualizerGL3D::Flag::Wireframe|
Shaders::MeshVisualizerGL3D::Flag::NoGeometryShader};
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe|
Shaders::MeshVisualizerGL3D::Flag::NoGeometryShader)};
shader.setColor(0x2f83cc_rgbf)
.setWireframeColor(0xdcdcdc_rgbf)
.setTransformationMatrix(transformationMatrix)
@ -787,8 +805,8 @@ colorMapTexture
.setStorage(1, GL::TextureFormat::RGBA8, size)
.setSubImage(0, {}, ImageView2D{PixelFormat::RGB8Srgb, size, map});
Shaders::MeshVisualizerGL3D shader{
Shaders::MeshVisualizerGL3D::Flag::InstancedObjectId};
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL3D::Flag::InstancedObjectId)};
shader.setColorMapTransformation(0.0f, 1.0f/Math::max(objectIds))
.setTransformationMatrix(transformationMatrix)
.setProjectionMatrix(projectionMatrix)
@ -824,9 +842,9 @@ drawUniform.setData({
.setMaterialId(0)
});
Shaders::MeshVisualizerGL3D shader{
Shaders::MeshVisualizerGL3D::Flag::Wireframe|
Shaders::MeshVisualizerGL3D::Flag::UniformBuffers
Shaders::MeshVisualizerGL3D shader{Shaders::MeshVisualizerGL3D::Configuration{}
.setFlags(Shaders::MeshVisualizerGL3D::Flag::Wireframe|
Shaders::MeshVisualizerGL3D::Flag::UniformBuffers)
};
shader
.setViewportSize(Vector2{GL::defaultFramebuffer.viewport().size()})
@ -923,8 +941,9 @@ mesh.addVertexBuffer(vertices, 0,
Matrix4 transformationMatrix, projectionMatrix;
GL::Texture2D diffuseTexture, specularTexture;
Shaders::PhongGL shader{Shaders::PhongGL::Flag::DiffuseTexture|
Shaders::PhongGL::Flag::SpecularTexture};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::DiffuseTexture|
Shaders::PhongGL::Flag::SpecularTexture)};
shader.bindTextures(nullptr, &diffuseTexture, &specularTexture, nullptr)
.setTransformationMatrix(transformationMatrix)
.setNormalMatrix(transformationMatrix.normalMatrix())
@ -938,7 +957,8 @@ shader.bindTextures(nullptr, &diffuseTexture, &specularTexture, nullptr)
/* [PhongGL-usage-lights] */
Matrix4 directionalLight, pointLight1, pointLight2; // camera-relative
Shaders::PhongGL shader{{}, 3}; // 3 lights
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setLightCount(3)};
shader
.setLightPositions({Vector4{directionalLight.up(), 0.0f},
Vector4{pointLight1.translation(), 1.0f},
@ -959,7 +979,8 @@ GL::Texture2D diffuseTexture;
/* [PhongGL-usage-lights-ambient] */
Trade::LightData ambientLight = DOXYGEN_ELLIPSIS(Trade::LightData{{}, {}, {}});
Shaders::PhongGL shader{Shaders::PhongGL::Flag::AmbientTexture|DOXYGEN_ELLIPSIS(Shaders::PhongGL::Flag::DiffuseTexture), DOXYGEN_ELLIPSIS(3)};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::AmbientTexture|DOXYGEN_ELLIPSIS(Shaders::PhongGL::Flag::DiffuseTexture))};
shader
.setAmbientColor(ambientColor + ambientLight.color()*ambientLight.intensity())
.bindAmbientTexture(diffuseTexture)
@ -971,8 +992,9 @@ shader
GL::Texture2D diffuseAlphaTexture;
Color3 diffuseRgb, specularRgb;
/* [PhongGL-usage-alpha] */
Shaders::PhongGL shader{Shaders::PhongGL::Flag::AmbientTexture|
Shaders::PhongGL::Flag::DiffuseTexture};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::AmbientTexture|
Shaders::PhongGL::Flag::DiffuseTexture)};
shader.bindTextures(&diffuseAlphaTexture, &diffuseAlphaTexture, nullptr, nullptr)
.setAmbientColor(0x000000ff_rgbaf)
.setDiffuseColor(Color4{diffuseRgb, 0.0f})
@ -1010,7 +1032,8 @@ drawUniform.setData({
.setMaterialId(0)
});
Shaders::PhongGL shader{Shaders::PhongGL::Flag::UniformBuffers};
Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
.setFlags(Shaders::PhongGL::Flag::UniformBuffers)};
shader
.bindProjectionBuffer(projectionUniform)
.bindLightBuffer(lightUniform)
@ -1075,7 +1098,8 @@ drawUniform.setData({
.setMaterialId(0)
});
Shaders::VectorGL2D shader{Shaders::VectorGL2D::Flag::UniformBuffers};
Shaders::VectorGL2D shader{Shaders::VectorGL2D::Configuration{}
.setFlags(Shaders::VectorGL2D::Flag::UniformBuffers)};
shader
.bindTransformationProjectionBuffer(projectionTransformationUniform)
.bindMaterialBuffer(materialUniform)
@ -1129,7 +1153,8 @@ projectionTransformationUniform.setData({
.setTransformationProjectionMatrix(projectionMatrix*transformationMatrix)
});
Shaders::VertexColorGL3D shader{Shaders::VertexColorGL3D::Flag::UniformBuffers};
Shaders::VertexColorGL3D shader{Shaders::VertexColorGL3D::Configuration{}
.setFlags(Shaders::VertexColorGL3D::Flag::UniformBuffers)};
shader
.bindTransformationProjectionBuffer(projectionTransformationUniform)
.draw(mesh);

28
src/Magnum/MeshTools/Test/CompileGLTest.cpp
Unescape View File

@ -123,12 +123,14 @@ struct CompileGLTest: GL::OpenGLTester {
PluginManager::Manager<Trade::AbstractImporter> _manager{"nonexistent"};
Shaders::FlatGL2D _flat2D;
Shaders::FlatGL2D _flatTextured2D{Shaders::FlatGL2D::Flag::Textured};
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::Flag::Textured};
Shaders::FlatGL3D _flatTextured3D{Shaders::FlatGL3D::Configuration{}
.setFlags(Shaders::FlatGL3D::Flag::Textured)};
#ifndef MAGNUM_TARGET_GLES2
Shaders::FlatGL3D _flatObjectId3D{NoCreate};
#endif
@ -331,8 +333,10 @@ CompileGLTest::CompileGLTest() {
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
_flatObjectId2D = Shaders::FlatGL2D{Shaders::FlatGL2D::Flag::InstancedObjectId};
_flatObjectId3D = Shaders::FlatGL3D{Shaders::FlatGL3D::Flag::InstancedObjectId};
_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)
@ -351,14 +355,14 @@ CompileGLTest::CompileGLTest() {
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::geometry_shader>())
#endif
{
_meshVisualizer3D = Shaders::MeshVisualizerGL3D{
Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
Shaders::MeshVisualizerGL3D::Flag::BitangentDirection|
Shaders::MeshVisualizerGL3D::Flag::NormalDirection};
_meshVisualizerBitangentsFromTangents3D = Shaders::MeshVisualizerGL3D{
Shaders::MeshVisualizerGL3D::Flag::TangentDirection|
Shaders::MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
Shaders::MeshVisualizerGL3D::Flag::NormalDirection};
_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
}

64
src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp
Unescape View File

@ -374,7 +374,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::construct() {
auto&& data = ConstructData[testCaseInstanceId()];
setTestCaseDescription(data.name);
DistanceFieldVectorGL<dimensions> shader{data.flags};
DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(data.flags)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_VERIFY(shader.id());
{
@ -390,7 +391,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::construct() {
template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructAsync() {
setTestCaseTemplateName(Utility::format("{}", dimensions));
typename DistanceFieldVectorGL<dimensions>::CompileState state = DistanceFieldVectorGL<dimensions>::compile(DistanceFieldVectorGL2D::Flag::TextureTransformation);
typename DistanceFieldVectorGL<dimensions>::CompileState state = DistanceFieldVectorGL<dimensions>::compile(typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(DistanceFieldVectorGL2D::Flag::TextureTransformation));
CORRADE_COMPARE(state.flags(), DistanceFieldVectorGL2D::Flag::TextureTransformation);
while(!state.isLinkFinished())
@ -435,7 +437,10 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructUnifor
#endif
}
DistanceFieldVectorGL<dimensions> shader{data.flags, data.materialCount, data.drawCount};
DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_COMPARE(shader.materialCount(), data.materialCount);
CORRADE_COMPARE(shader.drawCount(), data.drawCount);
@ -458,7 +463,10 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructUnifor
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
typename DistanceFieldVectorGL<dimensions>::CompileState state = DistanceFieldVectorGL<dimensions>::compile(DistanceFieldVectorGL2D::Flag::UniformBuffers, 16, 48);
typename DistanceFieldVectorGL<dimensions>::CompileState state = DistanceFieldVectorGL<dimensions>::compile(typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(DistanceFieldVectorGL2D::Flag::UniformBuffers)
.setMaterialCount(16)
.setDrawCount(48));
CORRADE_COMPARE(state.flags(), DistanceFieldVectorGL2D::Flag::UniformBuffers);
CORRADE_COMPARE(state.materialCount(), 16);
CORRADE_COMPARE(state.drawCount(), 48);
@ -486,7 +494,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructUnifor
template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructMove() {
setTestCaseTemplateName(Utility::format("{}", dimensions));
DistanceFieldVectorGL<dimensions> a{DistanceFieldVectorGL<dimensions>::Flag::TextureTransformation};
DistanceFieldVectorGL<dimensions> a{typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(DistanceFieldVectorGL<dimensions>::Flag::TextureTransformation)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -513,7 +522,10 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructMoveUn
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
DistanceFieldVectorGL<dimensions> a{DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers, 2, 5};
DistanceFieldVectorGL<dimensions> a{typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers)
.setMaterialCount(2)
.setDrawCount(5)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -552,7 +564,10 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::constructUnifor
std::ostringstream out;
Error redirectError{&out};
DistanceFieldVectorGL<dimensions>{data.flags, data.materialCount, data.drawCount};
DistanceFieldVectorGL<dimensions>{typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(out.str(), Utility::formatString(
"Shaders::DistanceFieldVectorGL: {}\n", data.message));
}
@ -572,7 +587,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::setUniformUnifo
std::ostringstream out;
Error redirectError{&out};
DistanceFieldVectorGL<dimensions> shader{DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers};
DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers)};
shader.setTransformationProjectionMatrix({})
.setTextureMatrix({})
.setColor({})
@ -650,7 +666,8 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::bindTextureTran
Error redirectError{&out};
GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
DistanceFieldVectorGL<dimensions> shader{DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers};
DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers)};
shader.bindTextureTransformationBuffer(buffer)
.bindTextureTransformationBuffer(buffer, 0, 16);
CORRADE_COMPARE(out.str(),
@ -672,8 +689,11 @@ template<UnsignedInt dimensions> void DistanceFieldVectorGLTest::setWrongDrawOff
std::ostringstream out;
Error redirectError{&out};
DistanceFieldVectorGL<dimensions>{DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers, 2, 5}
.setDrawOffset(5);
DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(DistanceFieldVectorGL<dimensions>::Flag::UniformBuffers)
.setMaterialCount(2)
.setDrawCount(5)};
shader.setDrawOffset(5);
CORRADE_COMPARE(out.str(),
"Shaders::DistanceFieldVectorGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
}
@ -751,7 +771,8 @@ template<DistanceFieldVectorGL2D::Flag flag> void DistanceFieldVectorGLTest::ren
.setSubImage(0, {}, *image);
#endif
DistanceFieldVectorGL2D shader{flag};
DistanceFieldVectorGL2D shader{DistanceFieldVectorGL2D::Configuration{}
.setFlags(flag)};
shader.bindVectorTexture(texture);
if(flag == DistanceFieldVectorGL2D::Flag{}) {
@ -839,7 +860,8 @@ template<DistanceFieldVectorGL3D::Flag flag> void DistanceFieldVectorGLTest::ren
.setSubImage(0, {}, *image);
#endif
DistanceFieldVectorGL3D shader{flag};
DistanceFieldVectorGL3D shader{DistanceFieldVectorGL3D::Configuration{}
.setFlags(flag)};
shader.bindVectorTexture(texture);
if(flag == DistanceFieldVectorGL3D::Flag{}) {
@ -930,7 +952,8 @@ template<DistanceFieldVectorGL2D::Flag flag> void DistanceFieldVectorGLTest::ren
.setSubImage(0, {}, *image);
#endif
DistanceFieldVectorGL2D shader{data.flags|flag};
DistanceFieldVectorGL2D shader{DistanceFieldVectorGL2D::Configuration{}
.setFlags(data.flags|flag)};
shader.bindVectorTexture(texture);
if(flag == DistanceFieldVectorGL2D::Flag{}) {
@ -1038,7 +1061,8 @@ template<DistanceFieldVectorGL3D::Flag flag> void DistanceFieldVectorGLTest::ren
.setSubImage(0, {}, *image);
#endif
DistanceFieldVectorGL3D shader{data.flags|flag};
DistanceFieldVectorGL3D shader{DistanceFieldVectorGL3D::Configuration{}
.setFlags(data.flags|flag)};
shader.bindVectorTexture(texture);
if(flag == DistanceFieldVectorGL3D::Flag{}) {
@ -1235,7 +1259,10 @@ void DistanceFieldVectorGLTest::renderMulti2D() {
.setMaterialId(data.drawCount == 1 ? 0 : 0);
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
DistanceFieldVectorGL2D shader{DistanceFieldVectorGL2D::Flag::UniformBuffers|DistanceFieldVectorGL2D::Flag::TextureTransformation|data.flags, data.materialCount, data.drawCount};
DistanceFieldVectorGL2D shader{DistanceFieldVectorGL2D::Configuration{}
.setFlags(DistanceFieldVectorGL2D::Flag::UniformBuffers|DistanceFieldVectorGL2D::Flag::TextureTransformation|data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
shader.bindVectorTexture(vector);
/* Just one draw, rebinding UBOs each time */
@ -1441,7 +1468,10 @@ void DistanceFieldVectorGLTest::renderMulti3D() {
.setMaterialId(data.drawCount == 1 ? 0 : 0);
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
DistanceFieldVectorGL3D shader{DistanceFieldVectorGL3D::Flag::UniformBuffers|DistanceFieldVectorGL3D::Flag::TextureTransformation|data.flags, data.materialCount, data.drawCount};
DistanceFieldVectorGL3D shader{DistanceFieldVectorGL3D::Configuration{}
.setFlags(DistanceFieldVectorGL3D::Flag::UniformBuffers|DistanceFieldVectorGL3D::Flag::TextureTransformation|data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
shader.bindVectorTexture(vector);
/* Just one draw, rebinding UBOs each time */

113
src/Magnum/Shaders/Test/FlatGLTest.cpp
Unescape View File

@ -853,7 +853,8 @@ template<UnsignedInt dimensions> void FlatGLTest::construct() {
CORRADE_SKIP(GL::Extensions::EXT::texture_array::string() << "is not supported.");
#endif
FlatGL<dimensions> shader{data.flags};
FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
.setFlags(data.flags)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_VERIFY(shader.id());
{
@ -869,7 +870,8 @@ template<UnsignedInt dimensions> void FlatGLTest::construct() {
template<UnsignedInt dimensions> void FlatGLTest::constructAsync() {
setTestCaseTemplateName(Utility::format("{}", dimensions));
typename FlatGL<dimensions>::CompileState state = FlatGL<dimensions>::compile(FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation);
typename FlatGL<dimensions>::CompileState state = FlatGL<dimensions>::compile(typename FlatGL<dimensions>::Configuration{}
.setFlags(FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation));
CORRADE_COMPARE(state.flags(), FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation);
while(!state.isLinkFinished())
@ -918,7 +920,10 @@ template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffers() {
#endif
}
FlatGL<dimensions> shader{data.flags, data.materialCount, data.drawCount};
FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_COMPARE(shader.materialCount(), data.materialCount);
CORRADE_COMPARE(shader.drawCount(), data.drawCount);
@ -941,7 +946,10 @@ template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffersAsync()
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
typename FlatGL<dimensions>::CompileState state = FlatGL<dimensions>::compile(FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::AlphaMask, 8, 48);
typename FlatGL<dimensions>::CompileState state = FlatGL<dimensions>::compile(typename FlatGL<dimensions>::Configuration{}
.setFlags(FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::AlphaMask)
.setMaterialCount(8)
.setDrawCount(48));
CORRADE_COMPARE(state.flags(), FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::AlphaMask);
CORRADE_COMPARE(state.materialCount(), 8);
CORRADE_COMPARE(state.drawCount(), 48);
@ -969,7 +977,8 @@ template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffersAsync()
template<UnsignedInt dimensions> void FlatGLTest::constructMove() {
setTestCaseTemplateName(Utility::format("{}", dimensions));
FlatGL<dimensions> a{FlatGL<dimensions>::Flag::Textured};
FlatGL<dimensions> a{typename FlatGL<dimensions>::Configuration{}
.setFlags(FlatGL<dimensions>::Flag::Textured)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -996,7 +1005,10 @@ template<UnsignedInt dimensions> void FlatGLTest::constructMoveUniformBuffers()
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
FlatGL<dimensions> a{FlatGL<dimensions>::Flag::UniformBuffers, 2, 5};
FlatGL<dimensions> a{typename FlatGL<dimensions>::Configuration{}
.setFlags(FlatGL<dimensions>::Flag::UniformBuffers)
.setMaterialCount(2)
.setDrawCount(5)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -1028,7 +1040,8 @@ template<UnsignedInt dimensions> void FlatGLTest::constructInvalid() {
std::ostringstream out;
Error redirectError{&out};
FlatGL<dimensions>{data.flags};
FlatGL<dimensions>{typename FlatGL<dimensions>::Configuration{}
.setFlags(data.flags)};
CORRADE_COMPARE(out.str(), Utility::formatString(
"Shaders::FlatGL: {}\n", data.message));
}
@ -1048,7 +1061,10 @@ template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffersInvalid
std::ostringstream out;
Error redirectError{&out};
FlatGL<dimensions>{data.flags, data.materialCount, data.drawCount};
FlatGL<dimensions>{typename FlatGL<dimensions>::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(out.str(), Utility::formatString(
"Shaders::FlatGL: {}\n", data.message));
}
@ -1068,7 +1084,8 @@ template<UnsignedInt dimensions> void FlatGLTest::setUniformUniformBuffersEnable
std::ostringstream out;
Error redirectError{&out};
FlatGL<dimensions> shader{FlatGL<dimensions>::Flag::UniformBuffers};
FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
.setFlags(FlatGL<dimensions>::Flag::UniformBuffers)};
shader.setTransformationProjectionMatrix({})
.setTextureMatrix({})
.setTextureLayer({})
@ -1131,7 +1148,8 @@ template<UnsignedInt dimensions> void FlatGLTest::bindTexturesInvalid() {
std::ostringstream out;
Error redirectError{&out};
FlatGL<dimensions> shader{data.flags};
FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
.setFlags(data.flags)};
GL::Texture2D texture;
shader.bindTexture(texture);
#ifndef MAGNUM_TARGET_GLES2
@ -1156,7 +1174,8 @@ template<UnsignedInt dimensions> void FlatGLTest::bindTextureArraysInvalid() {
std::ostringstream out;
Error redirectError{&out};
FlatGL<dimensions> shader{data.flags};
FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
.setFlags(data.flags)};
GL::Texture2DArray textureArray;
shader.bindTexture(textureArray);
shader.bindObjectIdTexture(textureArray);
@ -1226,7 +1245,8 @@ template<UnsignedInt dimensions> void FlatGLTest::bindTextureTransformBufferNotE
Error redirectError{&out};
GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
FlatGL<dimensions> shader{FlatGL<dimensions>::Flag::UniformBuffers};
FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
.setFlags(FlatGL<dimensions>::Flag::UniformBuffers)};
shader.bindTextureTransformationBuffer(buffer)
.bindTextureTransformationBuffer(buffer, 0, 16);
CORRADE_COMPARE(out.str(),
@ -1265,8 +1285,11 @@ template<UnsignedInt dimensions> void FlatGLTest::setWrongDrawOffset() {
std::ostringstream out;
Error redirectError{&out};
FlatGL<dimensions>{FlatGL<dimensions>::Flag::UniformBuffers, 2, 5}
.setDrawOffset(5);
FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
.setFlags(FlatGL<dimensions>::Flag::UniformBuffers)
.setMaterialCount(2)
.setDrawCount(5)};
shader.setDrawOffset(5);
CORRADE_COMPARE(out.str(),
"Shaders::FlatGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
}
@ -1313,7 +1336,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderDefaults2D() {
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32));
FlatGL2D shader{flag};
FlatGL2D shader{FlatGL2D::Configuration{}
.setFlags(flag)};
if(flag == FlatGL2D::Flag{}) {
shader.draw(circle);
@ -1366,7 +1390,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderDefaults3D() {
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
FlatGL3D shader{flag};
FlatGL3D shader{FlatGL3D::Configuration{}
.setFlags(flag)};
if(flag == FlatGL3D::Flag{}) {
shader.draw(sphere);
@ -1419,7 +1444,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderColored2D() {
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32));
FlatGL2D shader{flag};
FlatGL2D shader{FlatGL2D::Configuration{}
.setFlags(flag)};
if(flag == FlatGL2D::Flag{}) {
shader
@ -1482,7 +1508,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderColored3D() {
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
FlatGL3D shader{flag};
FlatGL3D shader{FlatGL3D::Configuration{}
.setFlags(flag)};
if(flag == FlatGL3D::Flag{}) {
shader
@ -1586,7 +1613,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderSinglePixelTextured2D() {
flags |= FlatGL2D::Flag::TextureTransformation;
}
#endif
FlatGL2D shader{flags};
FlatGL2D shader{FlatGL2D::Configuration{}
.setFlags(flags)};
const Color4ub imageData[]{ 0x9999ff_rgb };
ImageView2D image{PixelFormat::RGBA8Unorm, Vector2i{1}, imageData};
@ -1698,7 +1726,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderSinglePixelTextured3D() {
flags |= FlatGL3D::Flag::TextureTransformation;
}
#endif
FlatGL3D shader{flags};
FlatGL3D shader{FlatGL3D::Configuration{}
.setFlags(flags)};
const Color4ub imageData[]{ 0x9999ff_rgb };
ImageView2D image{PixelFormat::RGBA8Unorm, Vector2i{1}, imageData};
@ -1830,7 +1859,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderTextured2D() {
flags |= FlatGL2D::Flag::TextureTransformation;
}
#endif
FlatGL2D shader{flags};
FlatGL2D shader{FlatGL2D::Configuration{}
.setFlags(flags)};
GL::Texture2D texture{NoCreate};
#ifndef MAGNUM_TARGET_GLES2
@ -1956,7 +1986,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderTextured3D() {
flags |= FlatGL3D::Flag::TextureTransformation;
}
#endif
FlatGL3D shader{flags};
FlatGL3D shader{FlatGL3D::Configuration{}
.setFlags(flags)};
GL::Texture2D texture{NoCreate};
#ifndef MAGNUM_TARGET_GLES2
@ -2096,7 +2127,8 @@ template<class T, FlatGL2D::Flag flag> void FlatGLTest::renderVertexColor2D() {
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
FlatGL2D shader{FlatGL2D::Flag::Textured|FlatGL2D::Flag::VertexColor|flag};
FlatGL2D shader{FlatGL2D::Configuration{}
.setFlags(FlatGL2D::Flag::Textured|FlatGL2D::Flag::VertexColor|flag)};
shader.bindTexture(texture);
if(flag == FlatGL2D::Flag{}) {
@ -2185,7 +2217,8 @@ template<class T, FlatGL2D::Flag flag> void FlatGLTest::renderVertexColor3D() {
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
FlatGL3D shader{FlatGL3D::Flag::Textured|FlatGL3D::Flag::VertexColor|flag};
FlatGL3D shader{FlatGL3D::Configuration{}
.setFlags(FlatGL3D::Flag::Textured|FlatGL3D::Flag::VertexColor|flag)};
shader.bindTexture(texture);
if(flag == FlatGL2D::Flag{}) {
@ -2289,7 +2322,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderAlpha2D() {
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32,
Primitives::Circle2DFlag::TextureCoordinates));
FlatGL2D shader{data.flags|flag};
FlatGL2D shader{FlatGL2D::Configuration{}
.setFlags(data.flags|flag)};
shader.bindTexture(texture);
if(flag == FlatGL2D::Flag{}) {
@ -2375,7 +2409,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderAlpha3D() {
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
Primitives::UVSphereFlag::TextureCoordinates));
FlatGL3D shader{data.flags|flag};
FlatGL3D shader{FlatGL3D::Configuration{}
.setFlags(data.flags|flag)};
shader.bindTexture(texture);
if(flag == FlatGL2D::Flag{}) {
@ -2519,7 +2554,8 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderObjectId2D() {
CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
flags |= FlatGL2D::Flag::TextureTransformation;
}
FlatGL2D shader{FlatGL2D::Flag::ObjectId|flags};
FlatGL2D shader{FlatGL2D::Configuration{}
.setFlags(FlatGL2D::Flag::ObjectId|flags)};
GL::Texture2D texture{NoCreate};
GL::Texture2DArray textureArray{NoCreate};
@ -2651,7 +2687,8 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderObjectId3D() {
CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
flags |= FlatGL3D::Flag::TextureTransformation;
}
FlatGL3D shader{FlatGL3D::Flag::ObjectId|flags};
FlatGL3D shader{FlatGL3D::Configuration{}
.setFlags(FlatGL3D::Flag::ObjectId|flags)};
GL::Texture2D texture{NoCreate};
GL::Texture2DArray textureArray{NoCreate};
@ -2850,8 +2887,9 @@ template<FlatGL2D::Flag flag> void FlatGLTest::renderInstanced2D() {
)
.setInstanceCount(3);
FlatGL2D shader{FlatGL2D::Flag::VertexColor|
FlatGL2D::Flag::InstancedTransformation|data.flags|flag};
FlatGL2D shader{FlatGL2D::Configuration{}
.setFlags(FlatGL2D::Flag::VertexColor|
FlatGL2D::Flag::InstancedTransformation|data.flags|flag)};
GL::Texture2D texture{NoCreate};
#ifndef MAGNUM_TARGET_GLES2
@ -3163,8 +3201,9 @@ template<FlatGL3D::Flag flag> void FlatGLTest::renderInstanced3D() {
)
.setInstanceCount(3);
FlatGL3D shader{FlatGL3D::Flag::VertexColor|
FlatGL3D::Flag::InstancedTransformation|data.flags|flag};
FlatGL3D shader{FlatGL3D::Configuration{}
.setFlags(FlatGL3D::Flag::VertexColor|
FlatGL3D::Flag::InstancedTransformation|data.flags|flag)};
GL::Texture2D texture{NoCreate};
#ifndef MAGNUM_TARGET_GLES2
@ -3426,7 +3465,10 @@ void FlatGLTest::renderMulti2D() {
CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
#endif
FlatGL2D shader{FlatGL2D::Flag::UniformBuffers|data.flags, data.materialCount, data.drawCount};
FlatGL2D shader{FlatGL2D::Configuration{}
.setFlags(FlatGL2D::Flag::UniformBuffers|data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
GL::Texture2D texture{NoCreate};
GL::Texture2DArray textureArray{NoCreate};
@ -3762,7 +3804,10 @@ void FlatGLTest::renderMulti3D() {
CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
#endif
FlatGL3D shader{FlatGL3D::Flag::UniformBuffers|data.flags, data.materialCount, data.drawCount};
FlatGL3D shader{FlatGL3D::Configuration{}
.setFlags(FlatGL3D::Flag::UniformBuffers|data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
GL::Texture2D texture{NoCreate};
GL::Texture2DArray textureArray{NoCreate};

199
src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp
Unescape View File

@ -1403,7 +1403,8 @@ void MeshVisualizerGLTest::construct2D() {
}
#endif
MeshVisualizerGL2D shader{data.flags};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(data.flags)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_VERIFY(shader.id());
{
@ -1418,7 +1419,8 @@ void MeshVisualizerGLTest::construct2D() {
void MeshVisualizerGLTest::construct2DAsync() {
MeshVisualizerGL2D::CompileState state = MeshVisualizerGL2D::compile(MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader);
MeshVisualizerGL2D::CompileState state = MeshVisualizerGL2D::compile(MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader));
CORRADE_COMPARE(state.flags(), MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader);
while(!state.isLinkFinished())
@ -1503,7 +1505,10 @@ void MeshVisualizerGLTest::constructUniformBuffers2D() {
#endif
}
MeshVisualizerGL2D shader{data.flags, data.materialCount, data.drawCount};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_VERIFY(shader.id());
{
@ -1523,7 +1528,10 @@ void MeshVisualizerGLTest::constructUniformBuffers2DAsync() {
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
MeshVisualizerGL2D::CompileState state = MeshVisualizerGL2D::compile( MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader, 8, 55);
MeshVisualizerGL2D::CompileState state = MeshVisualizerGL2D::compile(MeshVisualizerGL2D::Configuration{}
.setFlags( MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)
.setMaterialCount(8)
.setDrawCount(55));
CORRADE_COMPARE(state.flags(), MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader);
CORRADE_COMPARE(state.materialCount(), 8);
CORRADE_COMPARE(state.drawCount(), 55);
@ -1595,7 +1603,8 @@ void MeshVisualizerGLTest::construct3D() {
}
#endif
MeshVisualizerGL3D shader{data.flags};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(data.flags)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_VERIFY(shader.id());
{
@ -1609,7 +1618,8 @@ void MeshVisualizerGLTest::construct3D() {
}
void MeshVisualizerGLTest::construct3DAsync() {
MeshVisualizerGL3D::CompileState state = MeshVisualizerGL3D::compile(MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader);
MeshVisualizerGL3D::CompileState state = MeshVisualizerGL3D::compile(MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader));
CORRADE_COMPARE(state.flags(), MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader);
while(!state.isLinkFinished())
@ -1694,7 +1704,10 @@ void MeshVisualizerGLTest::constructUniformBuffers3D() {
#endif
}
MeshVisualizerGL3D shader{data.flags, data.materialCount, data.drawCount};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_VERIFY(shader.id());
{
@ -1713,7 +1726,10 @@ void MeshVisualizerGLTest::constructUniformBuffers3DAsync() {
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
MeshVisualizerGL3D::CompileState state = MeshVisualizerGL3D::compile(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader, 6, 28);
MeshVisualizerGL3D::CompileState state = MeshVisualizerGL3D::compile(MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)
.setMaterialCount(6)
.setDrawCount(28));
CORRADE_COMPARE(state.flags(), MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader);
CORRADE_COMPARE(state.materialCount(), 6);
CORRADE_COMPARE(state.drawCount(), 28);
@ -1746,7 +1762,8 @@ void MeshVisualizerGLTest::construct2DInvalid() {
std::ostringstream out;
Error redirectError{&out};
MeshVisualizerGL2D{data.flags};
MeshVisualizerGL2D{MeshVisualizerGL2D::Configuration{}
.setFlags(data.flags)};
CORRADE_COMPARE(out.str(), Utility::formatString("Shaders::MeshVisualizerGL{}\n", data.message));
}
@ -1764,7 +1781,10 @@ void MeshVisualizerGLTest::constructUniformBuffers2DInvalid() {
std::ostringstream out;
Error redirectError{&out};
MeshVisualizerGL2D{data.flags, data.materialCount, data.drawCount};
MeshVisualizerGL2D{MeshVisualizerGL2D::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(out.str(), Utility::formatString("Shaders::MeshVisualizerGL2D: {}\n", data.message));
}
#endif
@ -1777,7 +1797,8 @@ void MeshVisualizerGLTest::construct3DInvalid() {
std::ostringstream out;
Error redirectError{&out};
MeshVisualizerGL3D{data.flags};
MeshVisualizerGL3D{MeshVisualizerGL3D::Configuration{}
.setFlags(data.flags)};
CORRADE_COMPARE(out.str(), Utility::formatString("Shaders::MeshVisualizerGL{}\n", data.message));
}
@ -1795,13 +1816,17 @@ void MeshVisualizerGLTest::constructUniformBuffers3DInvalid() {
std::ostringstream out;
Error redirectError{&out};
MeshVisualizerGL3D{data.flags, data.materialCount, data.drawCount};
MeshVisualizerGL3D{MeshVisualizerGL3D::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(out.str(), Utility::formatString("Shaders::MeshVisualizerGL3D: {}\n", data.message));
}
#endif
void MeshVisualizerGLTest::constructMove2D() {
MeshVisualizerGL2D a{MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader};
MeshVisualizerGL2D a{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -1826,7 +1851,10 @@ void MeshVisualizerGLTest::constructMoveUniformBuffers2D() {
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
MeshVisualizerGL2D a{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader, 2, 5};
MeshVisualizerGL2D a{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)
.setMaterialCount(2)
.setDrawCount(5)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -1850,7 +1878,8 @@ void MeshVisualizerGLTest::constructMoveUniformBuffers2D() {
#endif
void MeshVisualizerGLTest::constructMove3D() {
MeshVisualizerGL3D a{MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader};
MeshVisualizerGL3D a{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -1875,7 +1904,10 @@ void MeshVisualizerGLTest::constructMoveUniformBuffers3D() {
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
MeshVisualizerGL3D a{MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader, 2, 5};
MeshVisualizerGL3D a{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)
.setMaterialCount(2)
.setDrawCount(5)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -1910,7 +1942,8 @@ void MeshVisualizerGLTest::setUniformUniformBuffersEnabled2D() {
std::ostringstream out;
Error redirectError{&out};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)};
shader.setTransformationProjectionMatrix({})
.setTextureMatrix({})
.setTextureLayer({})
@ -1944,7 +1977,8 @@ void MeshVisualizerGLTest::setUniformUniformBuffersEnabled3D() {
std::ostringstream out;
Error redirectError{&out};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)};
shader.setProjectionMatrix({})
.setTransformationMatrix({})
.setTextureMatrix({})
@ -1989,7 +2023,8 @@ void MeshVisualizerGLTest::bindBufferUniformBuffersNotEnabled2D() {
Error redirectError{&out};
GL::Buffer buffer;
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)};
shader.bindTransformationProjectionBuffer(buffer)
.bindTransformationProjectionBuffer(buffer, 0, 16)
.bindDrawBuffer(buffer)
@ -2018,7 +2053,8 @@ void MeshVisualizerGLTest::bindBufferUniformBuffersNotEnabled3D() {
Error redirectError{&out};
GL::Buffer buffer;
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)};
shader.bindProjectionBuffer(buffer)
.bindProjectionBuffer(buffer, 0, 16)
.bindTransformationBuffer(buffer)
@ -2058,7 +2094,8 @@ void MeshVisualizerGLTest::bindObjectIdTextureInvalid2D() {
#endif
GL::Texture2D texture;
MeshVisualizerGL2D shader{data.flags2D};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(data.flags2D)};
std::ostringstream out;
Error redirectError{&out};
@ -2078,7 +2115,8 @@ void MeshVisualizerGLTest::bindObjectIdTextureInvalid3D() {
#endif
GL::Texture2D texture;
MeshVisualizerGL3D shader{data.flags3D};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(data.flags3D)};
std::ostringstream out;
Error redirectError{&out};
@ -2101,7 +2139,8 @@ void MeshVisualizerGLTest::bindObjectIdTextureArrayInvalid2D() {
Error redirectError{&out};
GL::Texture2DArray textureArray;
MeshVisualizerGL2D shader{data.flags2D};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(data.flags2D)};
shader.bindObjectIdTexture(textureArray);
CORRADE_COMPARE(out.str(), data.message);
@ -2122,7 +2161,8 @@ void MeshVisualizerGLTest::bindObjectIdTextureArrayInvalid3D() {
Error redirectError{&out};
GL::Texture2DArray textureArray;
MeshVisualizerGL3D shader{data.flags3D};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(data.flags3D)};
shader.bindObjectIdTexture(textureArray);
CORRADE_COMPARE(out.str(), data.message);
@ -2198,7 +2238,8 @@ void MeshVisualizerGLTest::setWireframeNotEnabled3D() {
void MeshVisualizerGLTest::setTextureMatrixNotEnabled2D() {
CORRADE_SKIP_IF_NO_ASSERT();
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::ObjectIdTexture};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::ObjectIdTexture)};
std::ostringstream out;
Error redirectError{&out};
@ -2210,7 +2251,8 @@ void MeshVisualizerGLTest::setTextureMatrixNotEnabled2D() {
void MeshVisualizerGLTest::setTextureMatrixNotEnabled3D() {
CORRADE_SKIP_IF_NO_ASSERT();
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::ObjectIdTexture};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::ObjectIdTexture)};
std::ostringstream out;
Error redirectError{&out};
@ -2222,7 +2264,8 @@ void MeshVisualizerGLTest::setTextureMatrixNotEnabled3D() {
void MeshVisualizerGLTest::setTextureLayerNotArray2D() {
CORRADE_SKIP_IF_NO_ASSERT();
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::ObjectIdTexture};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::ObjectIdTexture)};
std::ostringstream out;
Error redirectError{&out};
@ -2234,7 +2277,8 @@ void MeshVisualizerGLTest::setTextureLayerNotArray2D() {
void MeshVisualizerGLTest::setTextureLayerNotArray3D() {
CORRADE_SKIP_IF_NO_ASSERT();
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::ObjectIdTexture};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::ObjectIdTexture)};
std::ostringstream out;
Error redirectError{&out};
@ -2252,7 +2296,8 @@ void MeshVisualizerGLTest::bindTextureTransformBufferNotEnabled2D() {
#endif
GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::ObjectIdTexture};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::ObjectIdTexture)};
std::ostringstream out;
Error redirectError{&out};
@ -2272,7 +2317,8 @@ void MeshVisualizerGLTest::bindTextureTransformBufferNotEnabled3D() {
#endif
GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::ObjectIdTexture};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::ObjectIdTexture)};
std::ostringstream out;
Error redirectError{&out};
@ -2355,7 +2401,8 @@ void MeshVisualizerGLTest::setTangentBitangentNormalNotEnabled3D() {
std::ostringstream out;
Error redirectError{&out};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::Wireframe};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::Wireframe)};
shader.setNormalMatrix({})
.setLineWidth({})
.setLineLength({});
@ -2378,8 +2425,11 @@ void MeshVisualizerGLTest::setWrongDrawOffset2D() {
std::ostringstream out;
Error redirectError{&out};
MeshVisualizerGL2D{MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader, 2, 5}
.setDrawOffset(5);
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader)
.setMaterialCount(2)
.setDrawCount(5)};
shader.setDrawOffset(5);
CORRADE_COMPARE(out.str(),
"Shaders::MeshVisualizerGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
}
@ -2394,7 +2444,11 @@ void MeshVisualizerGLTest::setWrongDrawOffset3D() {
std::ostringstream out;
Error redirectError{&out};
MeshVisualizerGL3D{MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader, 2, 5}
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader)
.setMaterialCount(2)
.setDrawCount(5)};
shader
.setDrawOffset(5);
CORRADE_COMPARE(out.str(),
"Shaders::MeshVisualizerGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
@ -2463,7 +2517,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(16));
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::Wireframe|flag};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::Wireframe|flag)};
if(flag == MeshVisualizerGL2D::Flag{}) {
shader.draw(circle);
@ -2556,7 +2611,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
GL::Mesh sphere = MeshTools::compile(Primitives::icosphereSolid(1));
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::Wireframe|flag};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::Wireframe|flag)};
if(flag == MeshVisualizerGL3D::Flag{}) {
shader.draw(sphere);
@ -2651,7 +2707,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(16));
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::ObjectId|flag};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::ObjectId|flag)};
shader.bindColorMapTexture(_colorMapTexture);
if(flag == MeshVisualizerGL2D::Flag{}) {
@ -2704,7 +2761,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
GL::Mesh icosphere = MeshTools::compile(Primitives::icosphereSolid(0));
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::InstancedObjectId|flag};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::InstancedObjectId|flag)};
shader.bindColorMapTexture(_colorMapTexture);
if(flag == MeshVisualizerGL3D::Flag{}) {
@ -2785,7 +2843,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
Containers::arrayView(ids)}
}));
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::InstancedObjectId|flag};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::InstancedObjectId|flag)};
shader.bindColorMapTexture(colorMapTexture);
if(flag == MeshVisualizerGL2D::Flag{}) {
@ -2861,7 +2920,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
Containers::arrayView(ids)}
}));
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::InstancedObjectId|flag};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::InstancedObjectId|flag)};
shader.bindColorMapTexture(colorMapTexture);
if(flag == MeshVisualizerGL3D::Flag{}) {
@ -2921,7 +2981,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(16));
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::VertexId|flag};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::VertexId|flag)};
shader.bindColorMapTexture(_colorMapTexture);
if(flag == MeshVisualizerGL2D::Flag{}) {
@ -2972,7 +3033,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
GL::Mesh icosphere = MeshTools::compile(Primitives::icosphereSolid(0));
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::VertexId|flag};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::VertexId|flag)};
shader.bindColorMapTexture(_colorMapTexture);
if(flag == MeshVisualizerGL3D::Flag{}) {
@ -3056,7 +3118,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderDefault
GL::Mesh circle = MeshTools::compile(circleData);
MeshVisualizerGL2D shader{flags|flag};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(flags|flag)};
shader.bindColorMapTexture(_colorMapTexture);
if(flag == MeshVisualizerGL2D::Flag{}) {
@ -3137,7 +3200,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
GL::Mesh icosphere = MeshTools::compile(icosphereData);
MeshVisualizerGL3D shader{flags|flag};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(flags|flag)};
shader.bindColorMapTexture(_colorMapTexture);
if(flag == MeshVisualizerGL3D::Flag{}) {
@ -3196,9 +3260,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderDefault
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(4, 8,
Primitives::UVSphereFlag::Tangents));
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::TangentDirection|
MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|
MeshVisualizerGL3D::Flag::NormalDirection|flag};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::TangentDirection|MeshVisualizerGL3D::Flag::BitangentFromTangentDirection|MeshVisualizerGL3D::Flag::NormalDirection|flag)};
/** @todo make this unnecessary */
shader.setViewportSize({80, 80});
@ -3296,7 +3359,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderWirefra
}
} else circle = MeshTools::compile(circleData);
MeshVisualizerGL2D shader{data.flags|MeshVisualizerGL2D::Flag::Wireframe|flag};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(data.flags|MeshVisualizerGL2D::Flag::Wireframe|flag)};
shader.setViewportSize({80, 80});
if(flag == MeshVisualizerGL2D::Flag{}) {
@ -3425,7 +3489,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderWirefra
}
} else sphere = MeshTools::compile(sphereData);
MeshVisualizerGL3D shader{data.flags|MeshVisualizerGL3D::Flag::Wireframe|flag};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(data.flags|MeshVisualizerGL3D::Flag::Wireframe|flag)};
shader.setViewportSize({80, 80});
if(flag == MeshVisualizerGL3D::Flag{}) {
@ -3605,7 +3670,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderObjectV
CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
flags |= MeshVisualizerGL2D::Flag::TextureTransformation;
}
MeshVisualizerGL2D shader{flags};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(flags)};
shader
/* Shouldn't assert (nor warn) when wireframe is not enabled */
.setViewportSize({80, 80})
@ -3792,7 +3858,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderObjectV
CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
flags |= MeshVisualizerGL3D::Flag::TextureTransformation;
}
MeshVisualizerGL3D shader{flags};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(flags)};
shader
/* Shouldn't assert (nor warn) when wireframe is not enabled */
.setViewportSize({80, 80})
@ -3937,8 +4004,9 @@ void MeshVisualizerGLTest::renderWireframe3DPerspective() {
GL::Mesh plane = MeshTools::compile(Primitives::planeSolid());
MeshVisualizerGL3D{MeshVisualizerGL3D::Flag::Wireframe}
.setWireframeWidth(8.0f)
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::Wireframe)};
shader.setWireframeWidth(8.0f)
.setWireframeColor(0xff0000_rgbf)
.setViewportSize({80, 80})
.setTransformationMatrix(
@ -4067,7 +4135,9 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderTangent
Matrix4::scaling(Vector3::yScale(1.5f));
if(data.secondPassFlags) {
MeshVisualizerGL3D{data.secondPassFlags}
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(data.secondPassFlags)};
shader
/** @todo make this unnecessary */
.setViewportSize({80, 80})
.setTransformationMatrix(transformation)
@ -4077,7 +4147,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderTangent
.draw(mesh);
}
MeshVisualizerGL3D shader{data.flags|flag};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(data.flags|flag)};
/** @todo make this unnecessary */
shader.setViewportSize({80, 80});
if(data.flags & (MeshVisualizerGL3D::Flag::PrimitiveId|MeshVisualizerGL3D::Flag::ObjectId|MeshVisualizerGL3D::Flag::VertexId))
@ -4258,8 +4329,8 @@ template<MeshVisualizerGL2D::Flag flag> void MeshVisualizerGLTest::renderInstanc
)
.setInstanceCount(3);
MeshVisualizerGL2D shader{
MeshVisualizerGL2D::Flag::InstancedTransformation|data.flags|flag};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::InstancedTransformation|data.flags|flag)};
shader.setViewportSize(Vector2{RenderSize});
#ifndef MAGNUM_TARGET_GLES2
if(data.flags & (MeshVisualizerGL2D::Flag::VertexId|MeshVisualizerGL2D::Flag::ObjectId))
@ -4528,8 +4599,8 @@ template<MeshVisualizerGL3D::Flag flag> void MeshVisualizerGLTest::renderInstanc
)
.setInstanceCount(3);
MeshVisualizerGL3D shader{
MeshVisualizerGL3D::Flag::InstancedTransformation|data.flags|flag};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::InstancedTransformation|data.flags|flag)};
shader.setViewportSize(Vector2{RenderSize});
#ifndef MAGNUM_TARGET_GLES2
if(data.flags & (MeshVisualizerGL3D::Flag::VertexId|MeshVisualizerGL3D::Flag::ObjectId))
@ -4749,7 +4820,10 @@ void MeshVisualizerGLTest::renderMulti2D() {
CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
#endif
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Flag::UniformBuffers|data.flags, data.materialCount, data.drawCount};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(MeshVisualizerGL2D::Flag::UniformBuffers|data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
shader.setViewportSize(Vector2{RenderSize});
if(data.flags & (MeshVisualizerGL2D::Flag::VertexId|MeshVisualizerGL2D::Flag::ObjectId))
shader.bindColorMapTexture(_colorMapTexture);
@ -5069,7 +5143,10 @@ void MeshVisualizerGLTest::renderMulti3D() {
CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
#endif
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Flag::UniformBuffers|data.flags, data.materialCount, data.drawCount};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(MeshVisualizerGL3D::Flag::UniformBuffers|data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
shader.setViewportSize(Vector2{RenderSize});
if(data.flags & (MeshVisualizerGL3D::Flag::VertexId|MeshVisualizerGL3D::Flag::ObjectId))
shader.bindColorMapTexture(_colorMapTexture);

135
src/Magnum/Shaders/Test/PhongGLTest.cpp
Unescape View File

@ -1186,7 +1186,9 @@ void PhongGLTest::construct() {
CORRADE_SKIP(GL::Extensions::EXT::texture_array::string() << "is not supported.");
#endif
PhongGL shader{data.flags, data.lightCount};
PhongGL shader{PhongGL::Configuration{}
.setFlags(data.flags)
.setLightCount(data.lightCount)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_COMPARE(shader.lightCount(), data.lightCount);
CORRADE_VERIFY(shader.id());
@ -1201,7 +1203,9 @@ void PhongGLTest::construct() {
}
void PhongGLTest::constructAsync() {
PhongGL::CompileState state = PhongGL::compile(PhongGL::Flag::SpecularTexture|PhongGL::Flag::InstancedTextureOffset, 3);
PhongGL::CompileState state = PhongGL::compile(PhongGL::Configuration{}
.setFlags(PhongGL::Flag::SpecularTexture|PhongGL::Flag::InstancedTextureOffset)
.setLightCount(3));
CORRADE_COMPARE(state.flags(), PhongGL::Flag::SpecularTexture|PhongGL::Flag::InstancedTextureOffset);
CORRADE_COMPARE(state.lightCount(), 3);
@ -1250,7 +1254,11 @@ void PhongGLTest::constructUniformBuffers() {
#endif
}
PhongGL shader{data.flags, data.lightCount, data.materialCount, data.drawCount};
PhongGL shader{PhongGL::Configuration{}
.setFlags(data.flags)
.setLightCount(data.lightCount)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_COMPARE(shader.lightCount(), data.lightCount);
CORRADE_COMPARE(shader.materialCount(), data.materialCount);
@ -1272,7 +1280,11 @@ void PhongGLTest::constructUniformBuffersAsync() {
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
PhongGL::CompileState state = PhongGL::compile(PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling, 8, 8, 24);
PhongGL::CompileState state = PhongGL::compile(PhongGL::Configuration{}
.setFlags(PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling)
.setLightCount(8)
.setMaterialCount(8)
.setDrawCount(24));
CORRADE_COMPARE(state.flags(), PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling);
CORRADE_COMPARE(state.lightCount(), 8);
CORRADE_COMPARE(state.materialCount(), 8);
@ -1300,7 +1312,9 @@ void PhongGLTest::constructUniformBuffersAsync() {
#endif
void PhongGLTest::constructMove() {
PhongGL a{PhongGL::Flag::AlphaMask, 3};
PhongGL a{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::AlphaMask)
.setLightCount(3)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -1327,7 +1341,11 @@ void PhongGLTest::constructMoveUniformBuffers() {
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
PhongGL a{PhongGL::Flag::UniformBuffers, 3, 2, 5};
PhongGL a{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::UniformBuffers)
.setLightCount(3)
.setMaterialCount(2)
.setDrawCount(5)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -1360,7 +1378,8 @@ void PhongGLTest::constructInvalid() {
std::ostringstream out;
Error redirectError{&out};
PhongGL{data.flags};
PhongGL{PhongGL::Configuration{}
.setFlags(data.flags)};
CORRADE_COMPARE(out.str(), Utility::formatString(
"Shaders::PhongGL: {}\n", data.message));
}
@ -1379,7 +1398,11 @@ void PhongGLTest::constructUniformBuffersInvalid() {
std::ostringstream out;
Error redirectError{&out};
PhongGL{data.flags, data.lightCount, data.materialCount, data.drawCount};
PhongGL{PhongGL::Configuration{}
.setFlags(data.flags)
.setLightCount(data.lightCount)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(out.str(), Utility::formatString(
"Shaders::PhongGL: {}\n", data.message));
}
@ -1397,7 +1420,8 @@ void PhongGLTest::setUniformUniformBuffersEnabled() {
std::ostringstream out;
Error redirectError{&out};
PhongGL shader{PhongGL::Flag::UniformBuffers};
PhongGL shader{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::UniformBuffers)};
shader.setAmbientColor({})
.setDiffuseColor({})
.setNormalTextureScale({})
@ -1494,7 +1518,8 @@ void PhongGLTest::bindTexturesInvalid() {
Error redirectError{&out};
GL::Texture2D texture;
PhongGL shader{data.flags};
PhongGL shader{PhongGL::Configuration{}
.setFlags(data.flags)};
shader.bindAmbientTexture(texture)
.bindDiffuseTexture(texture)
.bindSpecularTexture(texture)
@ -1523,7 +1548,8 @@ void PhongGLTest::bindTextureArraysInvalid() {
Error redirectError{&out};
GL::Texture2DArray textureArray;
PhongGL shader{data.flags};
PhongGL shader{PhongGL::Configuration{}
.setFlags(data.flags)};
shader.bindAmbientTexture(textureArray)
.bindDiffuseTexture(textureArray)
.bindSpecularTexture(textureArray)
@ -1554,7 +1580,8 @@ void PhongGLTest::setSpecularDisabled() {
Error redirectError{&out};
GL::Texture2D texture;
PhongGL shader{PhongGL::Flag::NoSpecular};
PhongGL shader{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::NoSpecular)};
shader.setSpecularColor({})
.setShininess({})
/* {{}} makes GCC 4.8 warn about zero as null pointer constant */
@ -1621,7 +1648,8 @@ void PhongGLTest::bindTextureTransformBufferNotEnabled() {
Error redirectError{&out};
GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
PhongGL shader{PhongGL::Flag::UniformBuffers};
PhongGL shader{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::UniformBuffers)};
shader.bindTextureTransformationBuffer(buffer)
.bindTextureTransformationBuffer(buffer, 0, 16);
CORRADE_COMPARE(out.str(),
@ -1650,7 +1678,9 @@ void PhongGLTest::setWrongLightCount() {
std::ostringstream out;
Error redirectError{&out};
PhongGL{{}, 5}
PhongGL shader{PhongGL::Configuration{}
.setLightCount(5)};
shader
.setLightColors({Color3{}})
.setLightPositions({Vector4{}})
.setLightRanges({0.0f});
@ -1665,7 +1695,9 @@ void PhongGLTest::setWrongLightId() {
std::ostringstream out;
Error redirectError{&out};
PhongGL{{}, 3}
PhongGL shader{PhongGL::Configuration{}
.setLightCount(3)};
shader
.setLightColor(3, Color3{})
.setLightPosition(3, Vector4{})
.setLightRange(3, 0.0f);
@ -1686,8 +1718,12 @@ void PhongGLTest::setWrongDrawOffset() {
std::ostringstream out;
Error redirectError{&out};
PhongGL{PhongGL::Flag::UniformBuffers, 1, 2, 5}
.setDrawOffset(5);
PhongGL shader{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::UniformBuffers)
.setLightCount(1)
.setMaterialCount(2)
.setDrawCount(5)};
shader.setDrawOffset(5);
CORRADE_COMPARE(out.str(),
"Shaders::PhongGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
}
@ -1740,7 +1776,8 @@ template<PhongGL::Flag flag> void PhongGLTest::renderDefaults() {
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
PhongGL shader{flag};
PhongGL shader{PhongGL::Configuration{}
.setFlags(flag)};
if(flag == PhongGL::Flag{}) {
shader.draw(sphere);
@ -1816,7 +1853,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderColored() {
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
PhongGL shader{flag, 2};
PhongGL shader{PhongGL::Configuration{}
.setFlags(flag)
.setLightCount(2)};
if(flag == PhongGL::Flag{}) {
shader
@ -1944,7 +1983,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderSinglePixelTextured() {
flags |= PhongGL::Flag::TextureTransformation;
}
#endif
PhongGL shader{flags, 2};
PhongGL shader{PhongGL::Configuration{}
.setFlags(flags)
.setLightCount(2)};
const Color4ub ambientData[]{ 0x330033_rgb };
ImageView2D ambientImage{PixelFormat::RGBA8Unorm, Vector2i{1}, ambientData};
@ -2130,7 +2171,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderTextured() {
flags |= PhongGL::Flag::TextureTransformation;
}
#endif
PhongGL shader{flags, 2};
PhongGL shader{PhongGL::Configuration{}
.setFlags(flags)
.setLightCount(2)};
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
@ -2375,7 +2418,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderTexturedNormal() {
flags |= PhongGL::Flag::TextureTransformation;
}
#endif
PhongGL shader{flags, 2};
PhongGL shader{PhongGL::Configuration{}
.setFlags(flags)
.setLightCount(2)};
GL::Texture2D normal{NoCreate};
#ifndef MAGNUM_TARGET_GLES2
@ -2576,7 +2621,9 @@ template<class T, PhongGL::Flag flag> void PhongGLTest::renderVertexColor() {
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
PhongGL shader{PhongGL::Flag::DiffuseTexture|PhongGL::Flag::VertexColor|flag, 2};
PhongGL shader{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::DiffuseTexture|PhongGL::Flag::VertexColor|flag)
.setLightCount(2)};
shader.bindDiffuseTexture(diffuse);
if(flag == PhongGL::Flag{}) {
@ -2672,7 +2719,8 @@ template<PhongGL::Flag flag> void PhongGLTest::renderShininess() {
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
PhongGL shader{flag|data.flags};
PhongGL shader{PhongGL::Configuration{}
.setFlags(flag|data.flags)};
if(flag == PhongGL::Flag{}) {
if(!(data.flags & PhongGL::Flag::NoSpecular)) shader
.setSpecularColor(data.specular)
@ -2860,7 +2908,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderAlpha() {
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
Primitives::UVSphereFlag::TextureCoordinates));
PhongGL shader{data.flags|flag, 2};
PhongGL shader{PhongGL::Configuration{}
.setFlags(data.flags|flag)
.setLightCount(2)};
shader.bindTextures(&ambient, &diffuse, nullptr, nullptr);
if(flag == PhongGL::Flag{}) {
@ -3026,7 +3076,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderObjectId() {
CORRADE_INFO("Texture arrays currently require texture transformation if UBOs are used, enabling implicitly.");
flags |= PhongGL::Flag::TextureTransformation;
}
PhongGL shader{PhongGL::Flag::ObjectId|flags, 2};
PhongGL shader{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::ObjectId|flags)
.setLightCount(2)};
GL::Texture2D texture{NoCreate};
GL::Texture2DArray textureArray{NoCreate};
@ -3178,7 +3230,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderLights() {
Matrix4 transformation =
Matrix4::translation({0.0f, 0.0f, -1.5f});
PhongGL shader{flag, 1};
PhongGL shader{PhongGL::Configuration{}
.setFlags(flag)
.setLightCount(1)};
if(flag == PhongGL::Flag{}) {
shader
/* Set non-black ambient to catch accidental NaNs -- the render
@ -3268,7 +3322,9 @@ void PhongGLTest::renderLightsSetOneByOne() {
Matrix4 transformation =
Matrix4::translation({0.0f, 0.0f, -1.5f});
PhongGL{{}, 2}
PhongGL shader{PhongGL::Configuration{}
.setLightCount(2)};
shader
/* Set non-black ambient to catch accidental NaNs -- the render should
never be fully black */
.setAmbientColor(0x222222_rgbf)
@ -3334,7 +3390,9 @@ void PhongGLTest::renderLowLightAngle() {
in the vertex shader, where the incorrect normalization caused the
fragment-interpolated light direction being incorrect, most visible with
long polygons and low light angles. */
PhongGL{{}, 1}
PhongGL shader{PhongGL::Configuration{}
.setLightCount(1)};
shader
.setLightPositions({{0.0f, 0.1f, 0.0f, 1.0f}})
.setShininess(200)
.setTransformationMatrix(transformation)
@ -3404,7 +3462,9 @@ void PhongGLTest::renderLightCulling() {
.setColor(0x669933_rgbf);
GL::Buffer lightUniform{lights};
PhongGL shader{PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling, 64};
PhongGL shader{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling)
.setLightCount(64)};
shader
.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
@ -3464,7 +3524,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderZeroLights() {
flags |= PhongGL::Flag::ObjectId;
}
#endif
PhongGL shader{flags|flag, 0};
PhongGL shader{PhongGL::Configuration{}
.setFlags(flags|flag)
.setLightCount(0)};
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
@ -3700,8 +3762,9 @@ template<PhongGL::Flag flag> void PhongGLTest::renderInstanced() {
)
.setInstanceCount(3);
PhongGL shader{PhongGL::Flag::VertexColor|
PhongGL::Flag::InstancedTransformation|data.flags|flag, 2};
PhongGL shader{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::VertexColor|PhongGL::Flag::InstancedTransformation|data.flags|flag)
.setLightCount(2)};
GL::Texture2D diffuse{NoCreate};
GL::Texture2D normal{NoCreate};
@ -4046,7 +4109,11 @@ void PhongGLTest::renderMulti() {
CORRADE_SKIP("UBOs with dynamically indexed arrays are a crashy dumpster fire on SwiftShader, can't test.");
#endif
PhongGL shader{PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling|data.flags, data.lightCount, data.materialCount, data.drawCount};
PhongGL shader{PhongGL::Configuration{}
.setFlags(PhongGL::Flag::UniformBuffers|PhongGL::Flag::LightCulling|data.flags)
.setLightCount(data.lightCount)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
GL::Texture2D diffuse{NoCreate};
GL::Texture2DArray diffuseArray{NoCreate};

36
src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp
Unescape View File

@ -594,9 +594,11 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::flat() {
}
#endif
FlatGL<dimensions> shader{data.flags
FlatGL<dimensions> shader{typename FlatGL<dimensions>::Configuration{}
.setFlags(data.flags)
#ifndef MAGNUM_TARGET_GLES2
, data.materialCount, data.drawCount
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)
#endif
};
@ -705,9 +707,12 @@ void ShadersGLBenchmark::phong() {
}
#endif
PhongGL shader{data.flags, data.lightCount
PhongGL shader{PhongGL::Configuration{}
.setFlags(data.flags)
.setLightCount(data.lightCount)
#ifndef MAGNUM_TARGET_GLES2
, data.materialCount, data.drawCount
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)
#endif
};
@ -873,9 +878,10 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::vertexColor() {
}
#endif
VertexColorGL<dimensions> shader{data.flags
VertexColorGL<dimensions> shader{typename VertexColorGL<dimensions>::Configuration{}
.setFlags(data.flags)
#ifndef MAGNUM_TARGET_GLES2
, data.drawCount
.setDrawCount(data.drawCount)
#endif
};
@ -932,9 +938,11 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::vector() {
}
#endif
VectorGL<dimensions> shader{data.flags
VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
.setFlags(data.flags)
#ifndef MAGNUM_TARGET_GLES2
, data.materialCount, data.drawCount
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)
#endif
};
shader.bindVectorTexture(_textureWhite);
@ -1004,9 +1012,11 @@ template<UnsignedInt dimensions> void ShadersGLBenchmark::distanceFieldVector()
}
#endif
DistanceFieldVectorGL<dimensions> shader{data.flags
DistanceFieldVectorGL<dimensions> shader{typename DistanceFieldVectorGL<dimensions>::Configuration{}
.setFlags(data.flags)
#ifndef MAGNUM_TARGET_GLES2
, data.materialCount, data.drawCount
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)
#endif
};
shader.bindVectorTexture(_textureWhite);
@ -1116,7 +1126,8 @@ void ShadersGLBenchmark::meshVisualizer2D() {
}
#endif
MeshVisualizerGL2D shader{data.flags};
MeshVisualizerGL2D shader{MeshVisualizerGL2D::Configuration{}
.setFlags(data.flags)};
shader.setViewportSize(Vector2{RenderSize});
#ifndef MAGNUM_TARGET_GLES2
if(data.flags & (MeshVisualizerGL2D::Flag::InstancedObjectId|MeshVisualizerGL2D::Flag::VertexId|MeshVisualizerGL2D::Flag::PrimitiveIdFromVertexId
@ -1250,7 +1261,8 @@ void ShadersGLBenchmark::meshVisualizer3D() {
}
#endif
MeshVisualizerGL3D shader{data.flags};
MeshVisualizerGL3D shader{MeshVisualizerGL3D::Configuration{}
.setFlags(data.flags)};
shader.setViewportSize(Vector2{RenderSize});
#ifndef MAGNUM_TARGET_GLES2

62
src/Magnum/Shaders/Test/VectorGLTest.cpp
Unescape View File

@ -370,7 +370,8 @@ template<UnsignedInt dimensions> void VectorGLTest::construct() {
auto&& data = ConstructData[testCaseInstanceId()];
setTestCaseDescription(data.name);
VectorGL<dimensions> shader{data.flags};
VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
.setFlags(data.flags)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_VERIFY(shader.id());
{
@ -386,7 +387,8 @@ template<UnsignedInt dimensions> void VectorGLTest::construct() {
template<UnsignedInt dimensions> void VectorGLTest::constructAsync() {
setTestCaseTemplateName(Utility::format("{}", dimensions));
typename VectorGL<dimensions>::CompileState state = VectorGL<dimensions>::compile(VectorGL2D::Flag::TextureTransformation);
typename VectorGL<dimensions>::CompileState state = VectorGL<dimensions>::compile(typename VectorGL<dimensions>::Configuration{}
.setFlags(VectorGL2D::Flag::TextureTransformation));
CORRADE_COMPARE(state.flags(), VectorGL2D::Flag::TextureTransformation);
while(!state.isLinkFinished())
@ -432,7 +434,10 @@ template<UnsignedInt dimensions> void VectorGLTest::constructUniformBuffers() {
#endif
}
VectorGL<dimensions> shader{data.flags, data.materialCount, data.drawCount};
VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_COMPARE(shader.drawCount(), data.drawCount);
CORRADE_VERIFY(shader.id());
@ -454,7 +459,10 @@ template<UnsignedInt dimensions> void VectorGLTest::constructUniformBuffersAsync
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
typename VectorGL<dimensions>::CompileState state = VectorGL<dimensions>::compile(VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation, 15, 42);
typename VectorGL<dimensions>::CompileState state = VectorGL<dimensions>::compile(typename VectorGL<dimensions>::Configuration{}
.setFlags(VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation)
.setMaterialCount(15)
.setDrawCount(42));
CORRADE_COMPARE(state.flags(), VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation);
CORRADE_COMPARE(state.materialCount(), 15);
CORRADE_COMPARE(state.drawCount(), 42);
@ -482,7 +490,8 @@ template<UnsignedInt dimensions> void VectorGLTest::constructUniformBuffersAsync
template<UnsignedInt dimensions> void VectorGLTest::constructMove() {
setTestCaseTemplateName(Utility::format("{}", dimensions));
VectorGL<dimensions> a{VectorGL<dimensions>::Flag::TextureTransformation};
VectorGL<dimensions> a{typename VectorGL<dimensions>::Configuration{}
.setFlags(VectorGL<dimensions>::Flag::TextureTransformation)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -509,7 +518,10 @@ template<UnsignedInt dimensions> void VectorGLTest::constructMoveUniformBuffers(
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
VectorGL<dimensions> a{VectorGL<dimensions>::Flag::UniformBuffers, 2, 5};
VectorGL<dimensions> a{typename VectorGL<dimensions>::Configuration{}
.setFlags(VectorGL<dimensions>::Flag::UniformBuffers)
.setMaterialCount(2)
.setDrawCount(5)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -547,7 +559,10 @@ template<UnsignedInt dimensions> void VectorGLTest::constructUniformBuffersInval
std::ostringstream out;
Error redirectError{&out};
VectorGL<dimensions>{data.flags, data.materialCount, data.drawCount};
VectorGL<dimensions>{typename VectorGL<dimensions>::Configuration{}
.setFlags(data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(out.str(), Utility::formatString(
"Shaders::VectorGL: {}\n", data.message));
}
@ -567,7 +582,8 @@ template<UnsignedInt dimensions> void VectorGLTest::setUniformUniformBuffersEnab
std::ostringstream out;
Error redirectError{&out};
VectorGL<dimensions> shader{VectorGL<dimensions>::Flag::UniformBuffers};
VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
.setFlags(VectorGL<dimensions>::Flag::UniformBuffers)};
shader.setTransformationProjectionMatrix({})
.setTextureMatrix({})
.setBackgroundColor({})
@ -641,7 +657,8 @@ template<UnsignedInt dimensions> void VectorGLTest::bindTextureTransformBufferNo
Error redirectError{&out};
GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
VectorGL<dimensions> shader{VectorGL<dimensions>::Flag::UniformBuffers};
VectorGL<dimensions> shader{typename VectorGL<dimensions>::Configuration{}
.setFlags(VectorGL<dimensions>::Flag::UniformBuffers)};
shader.bindTextureTransformationBuffer(buffer)
.bindTextureTransformationBuffer(buffer, 0, 16);
CORRADE_COMPARE(out.str(),
@ -663,7 +680,10 @@ template<UnsignedInt dimensions> void VectorGLTest::setWrongDrawOffset() {
std::ostringstream out;
Error redirectError{&out};
VectorGL<dimensions>{VectorGL<dimensions>::Flag::UniformBuffers, 2, 5}
VectorGL<dimensions>{typename VectorGL<dimensions>::Configuration{}
.setFlags(VectorGL<dimensions>::Flag::UniformBuffers)
.setMaterialCount(2)
.setDrawCount(5)}
.setDrawOffset(5);
CORRADE_COMPARE(out.str(),
"Shaders::VectorGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
@ -742,7 +762,8 @@ template<VectorGL2D::Flag flag> void VectorGLTest::renderDefaults2D() {
.setSubImage(0, {}, *image);
#endif
VectorGL2D shader{flag};
VectorGL2D shader{VectorGL2D::Configuration{}
.setFlags(flag)};
shader.bindVectorTexture(texture);
if(flag == VectorGL2D::Flag{}) {
@ -821,7 +842,8 @@ template<VectorGL3D::Flag flag> void VectorGLTest::renderDefaults3D() {
.setSubImage(0, {}, *image);
#endif
VectorGL3D shader{flag};
VectorGL3D shader{VectorGL3D::Configuration{}
.setFlags(flag)};
shader.bindVectorTexture(texture);
if(flag == VectorGL3D::Flag{}) {
@ -903,7 +925,8 @@ template<VectorGL2D::Flag flag> void VectorGLTest::render2D() {
.setSubImage(0, {}, *image);
#endif
VectorGL2D shader{data.flags|flag};
VectorGL2D shader{VectorGL2D::Configuration{}
.setFlags(data.flags|flag)};
shader.bindVectorTexture(texture);
if(flag == VectorGL2D::Flag{}) {
@ -1008,7 +1031,8 @@ template<VectorGL3D::Flag flag> void VectorGLTest::render3D() {
.setSubImage(0, {}, *image);
#endif
VectorGL3D shader{data.flags|flag};
VectorGL3D shader{VectorGL3D::Configuration{}
.setFlags(data.flags|flag)};
shader.bindVectorTexture(texture);
if(flag == VectorGL3D::Flag{}) {
@ -1200,7 +1224,10 @@ void VectorGLTest::renderMulti2D() {
.setMaterialId(data.drawCount == 1 ? 0 : 1);
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
VectorGL2D shader{VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation|data.flags, data.materialCount, data.drawCount};
VectorGL2D shader{VectorGL2D::Configuration{}
.setFlags(VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation|data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
shader.bindVectorTexture(vector);
/* Just one draw, rebinding UBOs each time */
@ -1406,7 +1433,10 @@ void VectorGLTest::renderMulti3D() {
.setMaterialId(data.drawCount == 1 ? 0 : 1);
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
VectorGL3D shader{VectorGL3D::Flag::UniformBuffers|VectorGL3D::Flag::TextureTransformation|data.flags, data.materialCount, data.drawCount};
VectorGL3D shader{VectorGL3D::Configuration{}
.setFlags(VectorGL3D::Flag::UniformBuffers|VectorGL3D::Flag::TextureTransformation|data.flags)
.setMaterialCount(data.materialCount)
.setDrawCount(data.drawCount)};
shader.bindVectorTexture(vector);
/* Just one draw, rebinding UBOs each time */

43
src/Magnum/Shaders/Test/VertexColorGLTest.cpp
Unescape View File

@ -367,7 +367,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::constructUniformBuffers
#endif
}
VertexColorGL<dimensions> shader{data.flags, data.drawCount};
VertexColorGL<dimensions> shader{typename VertexColorGL<dimensions>::Configuration{}
.setFlags(data.flags)
.setDrawCount(data.drawCount)};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_COMPARE(shader.drawCount(), data.drawCount);
CORRADE_VERIFY(shader.id());
@ -389,7 +391,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::constructUniformBuffers
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
typename VertexColorGL<dimensions>::CompileState state = VertexColorGL<dimensions>::compile(VertexColorGL2D::Flag::UniformBuffers, 63);
typename VertexColorGL<dimensions>::CompileState state = VertexColorGL<dimensions>::compile(typename VertexColorGL<dimensions>::Configuration{}
.setFlags(VertexColorGL2D::Flag::UniformBuffers)
.setDrawCount(63));
CORRADE_COMPARE(state.flags(), VertexColorGL2D::Flag::UniformBuffers);
CORRADE_COMPARE(state.drawCount(), 63);
@ -440,7 +444,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::constructMoveUniformBuf
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
VertexColorGL<dimensions> a{VertexColorGL<dimensions>::Flag::UniformBuffers, 5};
VertexColorGL<dimensions> a{typename VertexColorGL<dimensions>::Configuration{}
.setFlags(VertexColorGL<dimensions>::Flag::UniformBuffers)
.setDrawCount(5)};
const GLuint id = a.id();
CORRADE_VERIFY(id);
@ -474,7 +480,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::constructUniformBuffers
std::ostringstream out;
Error redirectError{&out};
VertexColorGL<dimensions>{VertexColorGL<dimensions>::Flag::UniformBuffers, 0};
VertexColorGL<dimensions>{typename VertexColorGL<dimensions>::Configuration{}
.setFlags(VertexColorGL<dimensions>::Flag::UniformBuffers)
.setDrawCount(0)};
CORRADE_COMPARE(out.str(),
"Shaders::VertexColorGL: draw count can't be zero\n");
}
@ -494,7 +502,8 @@ template<UnsignedInt dimensions> void VertexColorGLTest::setUniformUniformBuffer
std::ostringstream out;
Error redirectError{&out};
VertexColorGL<dimensions> shader{VertexColorGL<dimensions>::Flag::UniformBuffers};
VertexColorGL<dimensions> shader{typename VertexColorGL<dimensions>::Configuration{}
.setFlags(VertexColorGL<dimensions>::Flag::UniformBuffers)};
shader.setTransformationProjectionMatrix({});
CORRADE_COMPARE(out.str(),
"Shaders::VertexColorGL::setTransformationProjectionMatrix(): the shader was created with uniform buffers enabled\n");
@ -531,7 +540,9 @@ template<UnsignedInt dimensions> void VertexColorGLTest::setWrongDrawOffset() {
std::ostringstream out;
Error redirectError{&out};
VertexColorGL<dimensions>{VertexColorGL<dimensions>::Flag::UniformBuffers, 5}
VertexColorGL<dimensions>{typename VertexColorGL<dimensions>::Configuration{}
.setFlags(VertexColorGL<dimensions>::Flag::UniformBuffers)
.setDrawCount(5)}
.setDrawOffset(5);
CORRADE_COMPARE(out.str(),
"Shaders::VertexColorGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
@ -591,7 +602,8 @@ template<class T, VertexColorGL2D::Flag flag> void VertexColorGLTest::renderDefa
GL::Mesh circle = MeshTools::compile(circleData);
circle.addVertexBuffer(colors, 0, GL::Attribute<VertexColorGL2D::Color3::Location, T>{});
VertexColorGL2D shader{flag};
VertexColorGL2D shader{VertexColorGL2D::Configuration{}
.setFlags(flag)};
if(flag == VertexColorGL2D::Flag{}) {
shader.draw(circle);
@ -657,7 +669,8 @@ template<class T, VertexColorGL2D::Flag flag> void VertexColorGLTest::renderDefa
GL::Mesh sphere = MeshTools::compile(sphereData);
sphere.addVertexBuffer(colors, 0, GL::Attribute<VertexColorGL3D::Color4::Location, T>{});
VertexColorGL3D shader{flag};
VertexColorGL3D shader{VertexColorGL3D::Configuration{}
.setFlags(flag)};
if(flag == VertexColorGL3D::Flag{}) {
shader.draw(sphere);
@ -717,7 +730,8 @@ template<class T, VertexColorGL2D::Flag flag> void VertexColorGLTest::render2D()
GL::Mesh circle = MeshTools::compile(circleData);
circle.addVertexBuffer(colors, 0, GL::Attribute<VertexColorGL2D::Color3::Location, T>{});
VertexColorGL2D shader{flag};
VertexColorGL2D shader{VertexColorGL2D::Configuration{}
.setFlags(flag)};
if(flag == VertexColorGL2D::Flag{}) {
shader.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
@ -784,7 +798,8 @@ template<class T, VertexColorGL3D::Flag flag> void VertexColorGLTest::render3D()
GL::Mesh sphere = MeshTools::compile(sphereData);
sphere.addVertexBuffer(colors, 0, GL::Attribute<VertexColorGL3D::Color4::Location, T>{});
VertexColorGL3D shader{flag};
VertexColorGL3D shader{VertexColorGL3D::Configuration{}
.setFlags(flag)};
if(flag == VertexColorGL3D::Flag{}) {
shader.setTransformationProjectionMatrix(
@ -908,7 +923,9 @@ void VertexColorGLTest::renderMulti2D() {
);
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
VertexColorGL2D shader{VertexColorGL2D::Flag::UniformBuffers|data.flags, data.drawCount};
VertexColorGL2D shader{VertexColorGL2D::Configuration{}
.setFlags(VertexColorGL2D::Flag::UniformBuffers|data.flags)
.setDrawCount(data.drawCount)};
/* Just one draw, rebinding UBOs each time */
if(data.drawCount == 1) {
@ -1039,7 +1056,9 @@ void VertexColorGLTest::renderMulti3D() {
);
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
VertexColorGL3D shader{VertexColorGL3D::Flag::UniformBuffers|data.flags, data.drawCount};
VertexColorGL3D shader{VertexColorGL3D::Configuration{}
.setFlags(VertexColorGL3D::Flag::UniformBuffers|data.flags)
.setDrawCount(data.drawCount)};
/* Just one draw, rebinding UBOs each time */
if(data.drawCount == 1) {

Write Preview
Loading…
Cancel
Save