Browse Source

Test: most tests now pass on Zink as well.

Just adding a bunch of extension checks that I thought I would never
need again.
pull/427/merge
Vladimír Vondruš 6 years ago
parent
commit
86a5a63af9
  1. 7
      src/Magnum/DebugTools/Test/TextureImageGLTest.cpp
  2. 23
      src/Magnum/GL/Test/AbstractShaderProgramGLTest.cpp
  3. 16
      src/Magnum/GL/Test/FramebufferGLTest.cpp
  4. 83
      src/Magnum/MeshTools/Test/CompileGLTest.cpp
  5. 3
      src/Magnum/MeshTools/Test/FullScreenTriangleGLTest.cpp
  6. 43
      src/Magnum/Shaders/Test/FlatGLTest.cpp
  7. 70
      src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp
  8. 88
      src/Magnum/Shaders/Test/PhongGLTest.cpp

7
src/Magnum/DebugTools/Test/TextureImageGLTest.cpp

@ -29,7 +29,9 @@
#include "Magnum/ImageView.h"
#include "Magnum/PixelFormat.h"
#include "Magnum/DebugTools/TextureImage.h"
#include "Magnum/GL/Context.h"
#include "Magnum/GL/CubeMapTexture.h"
#include "Magnum/GL/Extensions.h"
#include "Magnum/GL/OpenGLTester.h"
#include "Magnum/GL/PixelFormat.h"
#include "Magnum/GL/Texture.h"
@ -204,6 +206,11 @@ constexpr UnsignedInt Data2DUInt[] = { 0xcafebabe,
0xdeadbabe };
void TextureImageGLTest::subImage2DUInt() {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::texture_integer>())
CORRADE_SKIP(GL::Extensions::EXT::texture_integer::string() + std::string(" is not supported"));
#endif
GL::Texture2D texture;
texture.setImage(0, GL::TextureFormat::R32UI, ImageView2D{GL::PixelFormat::RedInteger, GL::PixelType::UnsignedInt, Vector2i{2}, Data2DUInt});

23
src/Magnum/GL/Test/AbstractShaderProgramGLTest.cpp

@ -265,6 +265,9 @@ void AbstractShaderProgramGLTest::create() {
void AbstractShaderProgramGLTest::createMultipleOutputs() {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
Utility::Resource rs("AbstractShaderProgramGLTest");
Shader vert(
@ -319,6 +322,11 @@ void AbstractShaderProgramGLTest::createMultipleOutputs() {
#ifndef MAGNUM_TARGET_GLES
void AbstractShaderProgramGLTest::createMultipleOutputsIndexed() {
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::blend_func_extended>())
CORRADE_SKIP(GL::Extensions::ARB::blend_func_extended::string() + std::string(" is not supported"));
Utility::Resource rs("AbstractShaderProgramGLTest");
Shader vert(
@ -641,6 +649,11 @@ void AbstractShaderProgramGLTest::uniformDoubleArray() {
#ifndef MAGNUM_TARGET_GLES2
void AbstractShaderProgramGLTest::createUniformBlocks() {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() + std::string(" is not supported"));
#endif
Utility::Resource rs("AbstractShaderProgramGLTest");
Shader vert(
@ -693,6 +706,11 @@ void AbstractShaderProgramGLTest::createUniformBlocks() {
}
void AbstractShaderProgramGLTest::uniformBlockIndexNotFound() {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() + std::string(" is not supported"));
#endif
MyPublicShader program;
Shader vert(
@ -767,6 +785,11 @@ UniformBlockShader::UniformBlockShader() {
#endif
void AbstractShaderProgramGLTest::uniformBlock() {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() + std::string(" is not supported"));
#endif
UniformBlockShader shader;
MAGNUM_VERIFY_NO_GL_ERROR();

16
src/Magnum/GL/Test/FramebufferGLTest.cpp

@ -179,6 +179,7 @@ constexpr struct {
RenderbufferFormat renderbufferFormat;
PixelFormat expectedFormat;
PixelType expectedType;
bool integer;
} ImplementationColorReadFormatData[]{
{"classic",
#if !defined(MAGNUM_TARGET_GLES2) || !defined(MAGNUM_TARGET_WEBGL)
@ -188,14 +189,14 @@ constexpr struct {
#endif
PixelFormat::RGBA,
#if !defined(MAGNUM_TARGET_GLES2) || !defined(MAGNUM_TARGET_WEBGL)
PixelType::UnsignedByte
PixelType::UnsignedByte,
#else
GL::PixelType::UnsignedShort4444
GL::PixelType::UnsignedShort4444,
#endif
},
false},
#ifndef MAGNUM_TARGET_GLES2
{"integer", RenderbufferFormat::RG32UI, PixelFormat::RGInteger, PixelType::UnsignedInt},
{"float", RenderbufferFormat::RGBA16F, PixelFormat::RGBA, PixelType::Half}
{"integer", RenderbufferFormat::RG32UI, PixelFormat::RGInteger, PixelType::UnsignedInt, true},
{"float", RenderbufferFormat::RGBA16F, PixelFormat::RGBA, PixelType::Half, false}
#endif
};
@ -2255,6 +2256,11 @@ void FramebufferGLTest::implementationColorReadFormat() {
auto&& data = ImplementationColorReadFormatData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(data.integer && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::texture_integer>())
CORRADE_SKIP(GL::Extensions::EXT::texture_integer::string() + std::string(" is not supported"));
#endif
Renderbuffer color;
color.setStorage(data.renderbufferFormat, {32, 32});
Framebuffer framebuffer{{{}, {32, 32}}};

83
src/Magnum/MeshTools/Test/CompileGLTest.cpp

@ -120,12 +120,12 @@ struct CompileGLTest: GL::OpenGLTester {
Shaders::Flat2D _flat2D;
Shaders::Flat2D _flatTextured2D{Shaders::Flat2D::Flag::Textured};
#ifndef MAGNUM_TARGET_GLES2
Shaders::Flat2D _flatObjectId2D{Shaders::Flat2D::Flag::InstancedObjectId};
Shaders::Flat2D _flatObjectId2D{NoCreate};
#endif
Shaders::Flat3D _flat3D;
Shaders::Flat3D _flatTextured3D{Shaders::Flat3D::Flag::Textured};
#ifndef MAGNUM_TARGET_GLES2
Shaders::Flat3D _flatObjectId3D{Shaders::Flat3D::Flag::InstancedObjectId};
Shaders::Flat3D _flatObjectId3D{NoCreate};
#endif
Shaders::VertexColor2D _color2D;
Shaders::VertexColor3D _color3D;
@ -286,18 +286,8 @@ CompileGLTest::CompileGLTest() {
GL::RenderbufferFormat::RGBA4,
#endif
{32, 32});
#ifndef MAGNUM_TARGET_GLES2
_objectId.setStorage(GL::RenderbufferFormat::R32UI, {32, 32});
#endif
_framebuffer
.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, _color)
#ifndef MAGNUM_TARGET_GLES2
.attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, _objectId)
.mapForDraw({
{Shaders::Generic3D::ColorOutput, GL::Framebuffer::ColorAttachment{0}},
{Shaders::Generic3D::ObjectIdOutput, GL::Framebuffer::ColorAttachment{1}}
})
#endif
.bind();
_texture
.setMinificationFilter(SamplerFilter::Linear)
@ -312,6 +302,23 @@ CompileGLTest::CompileGLTest() {
{4, 4})
.setSubImage(0, {}, ImageView2D{PixelFormat::RGBA8Unorm, {4, 4}, ImageData});
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
_flatObjectId2D = Shaders::Flat2D{Shaders::Flat2D::Flag::InstancedObjectId};
_flatObjectId3D = Shaders::Flat3D{Shaders::Flat3D::Flag::InstancedObjectId};
_objectId.setStorage(GL::RenderbufferFormat::R32UI, {32, 32});
_framebuffer
.attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, _objectId)
.mapForDraw({
{Shaders::Generic3D::ColorOutput, GL::Framebuffer::ColorAttachment{0}},
{Shaders::Generic3D::ObjectIdOutput, GL::Framebuffer::ColorAttachment{1}}
});
}
#endif
/* Mesh visualizer shaders only if we have a GS */
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
#ifndef MAGNUM_TARGET_GLES
@ -363,6 +370,11 @@ template<class T> void CompileGLTest::twoDimensions() {
auto&& data = Data2D[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(data.flags & Flag::ObjectId && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
#ifdef MAGNUM_BUILD_DEPRECATED
CORRADE_IGNORE_DEPRECATED_PUSH /** @todo remove once MeshDataXD is gone */
if(std::is_same<T, Trade::MeshData2D>::value && data.flags & Flag::ObjectId)
@ -536,6 +548,11 @@ template<class T> void CompileGLTest::threeDimensions() {
auto&& data = Data3D[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(data.flags & Flag::ObjectId && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
#ifdef MAGNUM_BUILD_DEPRECATED
CORRADE_IGNORE_DEPRECATED_PUSH /** @todo remove once MeshDataXD is gone */
if(std::is_same<T, Trade::MeshData3D>::value && data.flags & (Flag::Tangents|Flag::Bitangents|Flag::BitangentsFromTangents|Flag::ObjectId))
@ -1030,26 +1047,32 @@ void CompileGLTest::packedAttributes() {
(DebugTools::CompareImageToFile{_manager, 2.0f, 0.259f}));
#ifndef MAGNUM_TARGET_GLES2
_framebuffer.clearColor(1, Vector4ui{27});
_flatObjectId3D
.setTransformationProjectionMatrix(projection*transformation)
.draw(mesh);
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
_framebuffer.clearColor(1, Vector4ui{27});
_flatObjectId3D
.setTransformationProjectionMatrix(projection*transformation)
.draw(mesh);
MAGNUM_VERIFY_NO_GL_ERROR();
MAGNUM_VERIFY_NO_GL_ERROR();
/* Object ID -- no need to verify the whole image, just check that pixels
on known places have expected values. SwiftShader insists that the read
format has to be 32bit, so the renderbuffer format is that too to make
it the same (ES3 Mesa complains if these don't match). */
_framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{1});
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete);
Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::R32UI});
MAGNUM_VERIFY_NO_GL_ERROR();
/* Outside of the object, cleared to 27 */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[2][2], 27);
/* Inside of the object, bottom and top half should be different */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[11][18], 13562);
CORRADE_COMPARE(image.pixels<UnsignedInt>()[19][15], 26234);
/* Object ID -- no need to verify the whole image, just check that
pixels on known places have expected values. SwiftShader insists
that the read format has to be 32bit, so the renderbuffer format is
that too to make it the same (ES3 Mesa complains if these don't
match). */
_framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{1});
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete);
Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::R32UI});
MAGNUM_VERIFY_NO_GL_ERROR();
/* Outside of the object, cleared to 27 */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[2][2], 27);
/* Inside of the object, bottom and top half should be different */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[11][18], 13562);
CORRADE_COMPARE(image.pixels<UnsignedInt>()[19][15], 26234);
}
#endif
}

3
src/Magnum/MeshTools/Test/FullScreenTriangleGLTest.cpp

@ -74,6 +74,9 @@ void FullScreenTriangleGLTest::test() {
auto&& data = VersionData[testCaseInstanceId()];
setTestCaseDescription(data.name);
if(!GL::Context::current().isVersionSupported(data.version))
CORRADE_SKIP("Version not supported");
struct FullscreenFlatShader: GL::AbstractShaderProgram {
FullscreenFlatShader(GL::Version version) {
Utility::Resource rs{"FullScreenTriangleTest"};

43
src/Magnum/Shaders/Test/FlatGLTest.cpp

@ -304,6 +304,11 @@ template<UnsignedInt dimensions> void FlatGLTest::construct() {
auto&& data = ConstructData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if((data.flags & Flat2D::Flag::ObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
Flat<dimensions> shader{data.flags};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_VERIFY(shader.id());
@ -1002,22 +1007,30 @@ void FlatGLTest::renderObjectIdSetup() {
_color = GL::Renderbuffer{};
_color.setStorage(GL::RenderbufferFormat::RGBA8, RenderSize);
_objectId = GL::Renderbuffer{};
_objectId.setStorage(GL::RenderbufferFormat::R32UI, RenderSize);
_framebuffer = GL::Framebuffer{{{}, RenderSize}};
_framebuffer
.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, _color)
.attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, _objectId)
.mapForDraw({
{Flat3D::ColorOutput, GL::Framebuffer::ColorAttachment{0}},
{Flat3D::ObjectIdOutput, GL::Framebuffer::ColorAttachment{1}}
})
_framebuffer.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, _color)
/* Pick a color that's directly representable on RGBA4 as well to
reduce artifacts (well, and this needs to be consistent with other
tests that *need* to run on WebGL 1) */
.clearColor(0, 0x111111_rgbf)
.clearColor(1, Vector4ui{27})
.bind();
/* If we don't have EXT_gpu_shader4, we likely don't have integer
framebuffers either (Mesa's Zink), so skip setting up integer
attachments to avoid GL errors */
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
_objectId = GL::Renderbuffer{};
_objectId.setStorage(GL::RenderbufferFormat::R32UI, RenderSize);
_framebuffer.attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, _objectId)
.mapForDraw({
{Flat2D::ColorOutput, GL::Framebuffer::ColorAttachment{0}},
{Flat2D::ObjectIdOutput, GL::Framebuffer::ColorAttachment{1}}
})
.clearColor(1, Vector4ui{27});
}
}
void FlatGLTest::renderObjectIdTeardown() {
@ -1030,6 +1043,11 @@ void FlatGLTest::renderObjectId2D() {
auto&& data = RenderObjectIdData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32));
@ -1083,6 +1101,11 @@ void FlatGLTest::renderObjectId3D() {
auto&& data = RenderObjectIdData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));

70
src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp

@ -519,6 +519,21 @@ void MeshVisualizerGLTest::construct2D() {
auto&& data = ConstructData2D[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if((data.flags & MeshVisualizer2D::Flag::InstancedObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(data.flags >= MeshVisualizer2D::Flag::PrimitiveIdFromVertexId &&
#ifndef MAGNUM_TARGET_GLES
!GL::Context::current().isVersionSupported(GL::Version::GL300)
#else
!GL::Context::current().isVersionSupported(GL::Version::GLES300)
#endif
) CORRADE_SKIP("gl_VertexID not supported.");
#endif
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(data.flags & MeshVisualizer2D::Flag::PrimitiveId && !(data.flags >= MeshVisualizer2D::Flag::PrimitiveIdFromVertexId) &&
#ifndef MAGNUM_TARGET_GLES
@ -546,6 +561,21 @@ void MeshVisualizerGLTest::construct3D() {
auto&& data = ConstructData3D[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if((data.flags & MeshVisualizer3D::Flag::InstancedObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(data.flags >= MeshVisualizer3D::Flag::PrimitiveIdFromVertexId &&
#ifndef MAGNUM_TARGET_GLES
!GL::Context::current().isVersionSupported(GL::Version::GL300)
#else
!GL::Context::current().isVersionSupported(GL::Version::GLES300)
#endif
) CORRADE_SKIP("gl_VertexID not supported.");
#endif
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(data.flags & MeshVisualizer3D::Flag::PrimitiveId && !(data.flags >= MeshVisualizer3D::Flag::PrimitiveIdFromVertexId) &&
#ifndef MAGNUM_TARGET_GLES
@ -1009,6 +1039,11 @@ void MeshVisualizerGLTest::renderDefaultsObjectId2D() {
auto&& data = ObjectIdDefaultsData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
/* Configure a texture with preset filtering and wrapping. The goal here is
that the default config should be filtering/wrapping-independent for the
first 256 items */
@ -1053,6 +1088,11 @@ void MeshVisualizerGLTest::renderDefaultsObjectId3D() {
auto&& data = ObjectIdDefaultsData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
/* Configure a texture with preset filtering and wrapping. The goal here is
that the default config should be filtering/wrapping-independent for the
first 256 items */
@ -1098,6 +1138,16 @@ void MeshVisualizerGLTest::renderDefaultsPrimitiveId2D() {
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImageImporter plugins not found.");
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(
#ifndef MAGNUM_TARGET_GLES
!GL::Context::current().isVersionSupported(GL::Version::GL300)
#else
!GL::Context::current().isVersionSupported(GL::Version::GLES300)
#endif
) CORRADE_SKIP("gl_VertexID not supported.");
#endif
MeshVisualizer2D::Flags flags;
#ifdef MAGNUM_TARGET_WEBGL
flags = MeshVisualizer2D::Flag::PrimitiveIdFromVertexId;
@ -1137,6 +1187,16 @@ void MeshVisualizerGLTest::renderDefaultsPrimitiveId3D() {
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImageImporter plugins not found.");
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(
#ifndef MAGNUM_TARGET_GLES
!GL::Context::current().isVersionSupported(GL::Version::GL300)
#else
!GL::Context::current().isVersionSupported(GL::Version::GLES300)
#endif
) CORRADE_SKIP("gl_VertexID not supported.");
#endif
MeshVisualizer2D::Flags flags;
#ifdef MAGNUM_TARGET_WEBGL
flags = MeshVisualizer2D::Flag::PrimitiveIdFromVertexId;
@ -1405,6 +1465,11 @@ void MeshVisualizerGLTest::renderObjectPrimitiveId2D() {
auto&& data = ObjectPrimitiveIdData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if((data.flags2D & MeshVisualizer2D::Flag::InstancedObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
#ifndef MAGNUM_TARGET_WEBGL
if(data.flags2D & MeshVisualizer2D::Flag::PrimitiveId && !(data.flags2D >= MeshVisualizer2D::Flag::PrimitiveIdFromVertexId) &&
#ifndef MAGNUM_TARGET_GLES
@ -1484,6 +1549,11 @@ void MeshVisualizerGLTest::renderObjectPrimitiveId3D() {
auto&& data = ObjectPrimitiveIdData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if((data.flags3D & MeshVisualizer3D::Flag::InstancedObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
#ifndef MAGNUM_TARGET_WEBGL
if(data.flags3D & MeshVisualizer3D::Flag::PrimitiveId && !(data.flags3D >= MeshVisualizer3D::Flag::PrimitiveIdFromVertexId) &&
#ifndef MAGNUM_TARGET_GLES

88
src/Magnum/Shaders/Test/PhongGLTest.cpp

@ -422,6 +422,11 @@ void PhongGLTest::construct() {
auto&& data = ConstructData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if((data.flags & Phong::Flag::ObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
Phong shader{data.flags, data.lightCount};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_COMPARE(shader.lightCount(), data.lightCount);
@ -1223,22 +1228,30 @@ void PhongGLTest::renderObjectIdSetup() {
_color = GL::Renderbuffer{};
_color.setStorage(GL::RenderbufferFormat::RGBA8, RenderSize);
_objectId = GL::Renderbuffer{};
_objectId.setStorage(GL::RenderbufferFormat::R32UI, RenderSize);
_framebuffer = GL::Framebuffer{{{}, RenderSize}};
_framebuffer
.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, _color)
.attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, _objectId)
.mapForDraw({
{Phong::ColorOutput, GL::Framebuffer::ColorAttachment{0}},
{Phong::ObjectIdOutput, GL::Framebuffer::ColorAttachment{1}}
})
_framebuffer.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, _color)
/* Pick a color that's directly representable on RGBA4 as well to
reduce artifacts (well, and this needs to be consistent with other
tests that *need* to run on WebGL 1) */
.clearColor(0, 0x111111_rgbf)
.clearColor(1, Vector4ui{27})
.bind();
/* If we don't have EXT_gpu_shader4, we likely don't have integer
framebuffers either (Mesa's Zink), so skip setting up integer
attachments to avoid GL errors */
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
_objectId = GL::Renderbuffer{};
_objectId.setStorage(GL::RenderbufferFormat::R32UI, RenderSize);
_framebuffer.attachRenderbuffer(GL::Framebuffer::ColorAttachment{1}, _objectId)
.mapForDraw({
{Phong::ColorOutput, GL::Framebuffer::ColorAttachment{0}},
{Phong::ObjectIdOutput, GL::Framebuffer::ColorAttachment{1}}
})
.clearColor(1, Vector4ui{27});
}
}
void PhongGLTest::renderObjectIdTeardown() {
@ -1251,6 +1264,11 @@ void PhongGLTest::renderObjectId() {
auto&& data = RenderObjectIdData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() + std::string(" is not supported"));
#endif
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
@ -1319,12 +1337,17 @@ void PhongGLTest::renderZeroLights() {
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
Primitives::UVSphereFlag::TextureCoordinates));
Phong shader{
Phong::Flag::AmbientTexture|Phong::Flag::AlphaMask
#ifndef MAGNUM_TARGET_GLES2
|Phong::Flag::ObjectId
#endif
, 0};
/* Enable also Object ID, if supported */
Phong::Flags flags = Phong::Flag::AmbientTexture|Phong::Flag::AlphaMask;
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
flags |= Phong::Flag::ObjectId;
}
#endif
Phong shader{flags, 0};
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
@ -1349,9 +1372,6 @@ void PhongGLTest::renderZeroLights() {
Matrix4::rotationX(15.0_degf))
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
/* Keep alpha mask at the default 0.5 to test the default */
#ifndef MAGNUM_TARGET_GLES2
.setObjectId(65534)
#endif
/* Passing a zero-sized light position / color array, shouldn't assert */
.setLightPositions({})
.setLightColors({})
@ -1362,6 +1382,15 @@ void PhongGLTest::renderZeroLights() {
.setSpecularColor(0xfa9922_rgbf)
.setShininess(0.2f);
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
shader.setObjectId(65534);
}
#endif
/* For proper Z order draw back faces first and then front faces */
GL::Renderer::setFaceCullingMode(GL::Renderer::PolygonFacing::Front);
shader.draw(sphere);
@ -1392,14 +1421,19 @@ void PhongGLTest::renderZeroLights() {
on known places have expected values. SwiftShader insists that the read
format has to be 32bit, so the renderbuffer format is that too to make
it the same (ES3 Mesa complains if these don't match). */
_framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{1});
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete);
Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::R32UI});
MAGNUM_VERIFY_NO_GL_ERROR();
/* Outside of the object, cleared to 27 */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[10][10], 27);
/* Inside of the object. Verify that it can hold 16 bits at least. */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[40][46], 65534);
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
_framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{1});
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete);
Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::R32UI});
MAGNUM_VERIFY_NO_GL_ERROR();
/* Outside of the object, cleared to 27 */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[10][10], 27);
/* Inside of the object. Verify that it can hold 16 bits at least. */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[40][46], 65534);
}
#endif
}

Loading…
Cancel
Save