ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
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
881a50f7fa
commit
86a5a63af9
8 changed files with 261 additions and 72 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  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
Unescape View File

@ -29,7 +29,9 @@
#include "Magnum/ImageView.h" #include "Magnum/ImageView.h"
#include "Magnum/PixelFormat.h" #include "Magnum/PixelFormat.h"
#include "Magnum/DebugTools/TextureImage.h" #include "Magnum/DebugTools/TextureImage.h"
#include "Magnum/GL/Context.h"
#include "Magnum/GL/CubeMapTexture.h" #include "Magnum/GL/CubeMapTexture.h"
#include "Magnum/GL/Extensions.h"
#include "Magnum/GL/OpenGLTester.h" #include "Magnum/GL/OpenGLTester.h"
#include "Magnum/GL/PixelFormat.h" #include "Magnum/GL/PixelFormat.h"
#include "Magnum/GL/Texture.h" #include "Magnum/GL/Texture.h"
@ -204,6 +206,11 @@ constexpr UnsignedInt Data2DUInt[] = { 0xcafebabe,
0xdeadbabe }; 0xdeadbabe };
void TextureImageGLTest::subImage2DUInt() { 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; GL::Texture2D texture;
texture.setImage(0, GL::TextureFormat::R32UI, ImageView2D{GL::PixelFormat::RedInteger, GL::PixelType::UnsignedInt, Vector2i{2}, Data2DUInt}); texture.setImage(0, GL::TextureFormat::R32UI, ImageView2D{GL::PixelFormat::RedInteger, GL::PixelType::UnsignedInt, Vector2i{2}, Data2DUInt});

23
src/Magnum/GL/Test/AbstractShaderProgramGLTest.cpp
Unescape View File

@ -265,6 +265,9 @@ void AbstractShaderProgramGLTest::create() {
void AbstractShaderProgramGLTest::createMultipleOutputs() { void AbstractShaderProgramGLTest::createMultipleOutputs() {
#ifndef MAGNUM_TARGET_GLES #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"); Utility::Resource rs("AbstractShaderProgramGLTest");
Shader vert( Shader vert(
@ -319,6 +322,11 @@ void AbstractShaderProgramGLTest::createMultipleOutputs() {
#ifndef MAGNUM_TARGET_GLES #ifndef MAGNUM_TARGET_GLES
void AbstractShaderProgramGLTest::createMultipleOutputsIndexed() { 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"); Utility::Resource rs("AbstractShaderProgramGLTest");
Shader vert( Shader vert(
@ -641,6 +649,11 @@ void AbstractShaderProgramGLTest::uniformDoubleArray() {
#ifndef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_GLES2
void AbstractShaderProgramGLTest::createUniformBlocks() { 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"); Utility::Resource rs("AbstractShaderProgramGLTest");
Shader vert( Shader vert(
@ -693,6 +706,11 @@ void AbstractShaderProgramGLTest::createUniformBlocks() {
} }
void AbstractShaderProgramGLTest::uniformBlockIndexNotFound() { 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; MyPublicShader program;
Shader vert( Shader vert(
@ -767,6 +785,11 @@ UniformBlockShader::UniformBlockShader() {
#endif #endif
void AbstractShaderProgramGLTest::uniformBlock() { 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; UniformBlockShader shader;
MAGNUM_VERIFY_NO_GL_ERROR(); MAGNUM_VERIFY_NO_GL_ERROR();

16
src/Magnum/GL/Test/FramebufferGLTest.cpp
Unescape View File

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

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

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

3
src/Magnum/MeshTools/Test/FullScreenTriangleGLTest.cpp
Unescape View File

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

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

@ -304,6 +304,11 @@ template<UnsignedInt dimensions> void FlatGLTest::construct() {
auto&& data = ConstructData[testCaseInstanceId()]; auto&& data = ConstructData[testCaseInstanceId()];
setTestCaseDescription(data.name); 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}; Flat<dimensions> shader{data.flags};
CORRADE_COMPARE(shader.flags(), data.flags); CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_VERIFY(shader.id()); CORRADE_VERIFY(shader.id());
@ -1002,22 +1007,30 @@ void FlatGLTest::renderObjectIdSetup() {
_color = GL::Renderbuffer{}; _color = GL::Renderbuffer{};
_color.setStorage(GL::RenderbufferFormat::RGBA8, RenderSize); _color.setStorage(GL::RenderbufferFormat::RGBA8, RenderSize);
_objectId = GL::Renderbuffer{};
_objectId.setStorage(GL::RenderbufferFormat::R32UI, RenderSize);
_framebuffer = GL::Framebuffer{{{}, RenderSize}}; _framebuffer = GL::Framebuffer{{{}, RenderSize}};
_framebuffer _framebuffer.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, _color)
.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}}
})
/* Pick a color that's directly representable on RGBA4 as well to /* Pick a color that's directly representable on RGBA4 as well to
reduce artifacts (well, and this needs to be consistent with other reduce artifacts (well, and this needs to be consistent with other
tests that *need* to run on WebGL 1) */ tests that *need* to run on WebGL 1) */
.clearColor(0, 0x111111_rgbf) .clearColor(0, 0x111111_rgbf)
.clearColor(1, Vector4ui{27})
.bind(); .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() { void FlatGLTest::renderObjectIdTeardown() {
@ -1030,6 +1043,11 @@ void FlatGLTest::renderObjectId2D() {
auto&& data = RenderObjectIdData[testCaseInstanceId()]; auto&& data = RenderObjectIdData[testCaseInstanceId()];
setTestCaseDescription(data.name); 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); CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32)); GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32));
@ -1083,6 +1101,11 @@ void FlatGLTest::renderObjectId3D() {
auto&& data = RenderObjectIdData[testCaseInstanceId()]; auto&& data = RenderObjectIdData[testCaseInstanceId()];
setTestCaseDescription(data.name); 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); CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32)); GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));

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

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

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

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

Write Preview
Loading…
Cancel
Save