ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8913 Commits
21 Branches
19 Tags
70 MiB
Tree: a95fa9f3de
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a95fa9f3de'
${ noResults }
magnum/src/Magnum/Shaders/Test/FlatGLTest.cpp

2998 lines
127 KiB
Raw Normal View History Unescape

Shaders: test compilation of Flat and VertexColor shaders.
13 years ago
/*
This file is part of Magnum.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
Updated copyright year.
5 years ago
2020, 2021 Vladimír Vondruš <mosra@centrum.cz>
Shaders: test compilation of Flat and VertexColor shaders.
13 years ago
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
#include <sstream>
Shaders: rendering tests for Flat shader.
7 years ago
#include <Corrade/Containers/Optional.h>
#include <Corrade/Containers/StridedArrayView.h>
#include <Corrade/PluginManager/Manager.h>
Adapted to Corrade changes. Mostly missing includes now.
7 years ago
#include <Corrade/Utility/DebugStl.h>
Shaders: rendering tests for Flat shader.
7 years ago
#include <Corrade/Utility/Directory.h>
Adapted to Corrade changes. Mostly missing includes now.
7 years ago
#include <Corrade/Utility/FormatStl.h>
Shaders: simplify Flat shader test.
8 years ago
Shaders: rendering tests for Flat shader.
7 years ago
#include "Magnum/Image.h"
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
#include "Magnum/ImageView.h"
#include "Magnum/PixelFormat.h"
Shaders: rendering tests for Flat shader.
7 years ago
#include "Magnum/DebugTools/CompareImage.h"
Shaders: implement instancing in Flat.
6 years ago
#include "Magnum/GL/Context.h"
#include "Magnum/GL/Extensions.h"
Shaders: rendering tests for Flat shader.
7 years ago
#include "Magnum/GL/Mesh.h"
#include "Magnum/GL/Framebuffer.h"
#include "Magnum/GL/Renderer.h"
#include "Magnum/GL/Renderbuffer.h"
#include "Magnum/GL/RenderbufferFormat.h"
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
#include "Magnum/GL/Texture.h"
#include "Magnum/GL/TextureFormat.h"
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
#include "Magnum/GL/OpenGLTester.h"
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
#include "Magnum/Math/Color.h"
#include "Magnum/Math/Matrix3.h"
#include "Magnum/Math/Matrix4.h"
Shaders: rendering tests for Flat shader.
7 years ago
#include "Magnum/MeshTools/Compile.h"
#include "Magnum/Primitives/Circle.h"
#include "Magnum/Primitives/UVSphere.h"
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
#include "Magnum/Shaders/FlatGL.h"
Shaders: rendering tests for Flat shader.
7 years ago
#include "Magnum/Trade/AbstractImporter.h"
#include "Magnum/Trade/ImageData.h"
Shaders: port tests away from MeshDataXD.
6 years ago
#include "Magnum/Trade/MeshData.h"
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
#include "Magnum/GL/MeshView.h"
#include "Magnum/MeshTools/Concatenate.h"
#include "Magnum/MeshTools/GenerateIndices.h"
#include "Magnum/Primitives/Cone.h"
#include "Magnum/Primitives/Plane.h"
#include "Magnum/Primitives/Square.h"
#include "Magnum/Shaders/Generic.h"
#include "Magnum/Shaders/Flat.h"
#endif
Shaders: rendering tests for Flat shader.
7 years ago
#include "configure.h"
Shaders: test compilation of Flat and VertexColor shaders.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
namespace Magnum { namespace Shaders { namespace Test { namespace {
Shaders: test compilation of Flat and VertexColor shaders.
13 years ago
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
struct FlatGLTest: GL::OpenGLTester {
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
explicit FlatGLTest();
Shaders: simplify Flat shader test.
8 years ago
template<UnsignedInt dimensions> void construct();
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void constructUniformBuffers();
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Shaders: simplify Flat shader test.
8 years ago
template<UnsignedInt dimensions> void constructMove();
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void constructMoveUniformBuffers();
#endif
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
template<UnsignedInt dimensions> void constructTextureTransformationNotTextured();
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
template<UnsignedInt dimensions> void constructUniformBuffersInvalid();
Shaders: add UBO support to all shaders.
5 years ago
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void setUniformUniformBuffersEnabled();
template<UnsignedInt dimensions> void bindBufferUniformBuffersNotEnabled();
#endif
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
template<UnsignedInt dimensions> void bindTextureNotEnabled();
Shaders: classical alpha masking support in Phong and Flat. Slow and ugly, is here only for making quick'n'dirty alpha masked drawing without a need for blending or depth sorting. Oh and also to support the glTF alpha mask feature. Again, beware: *slow*.
8 years ago
template<UnsignedInt dimensions> void setAlphaMaskNotEnabled();
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
template<UnsignedInt dimensions> void setTextureMatrixNotEnabled();
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: add UBO support to all shaders.
5 years ago
template<UnsignedInt dimensions> void bindTextureTransformBufferNotEnabled();
#endif
#ifndef MAGNUM_TARGET_GLES2
Shaders: support object ID output in Flat and Phong.
7 years ago
template<UnsignedInt dimensions> void setObjectIdNotEnabled();
#endif
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void setWrongDrawOffset();
#endif
Shaders: rendering tests for Flat shader.
7 years ago
void renderSetup();
void renderTeardown();
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag = FlatGL2D::Flag{}> void renderDefaults2D();
template<FlatGL3D::Flag flag = FlatGL3D::Flag{}> void renderDefaults3D();
template<FlatGL2D::Flag flag = FlatGL2D::Flag{}> void renderColored2D();
template<FlatGL3D::Flag flag = FlatGL3D::Flag{}> void renderColored3D();
template<FlatGL2D::Flag flag = FlatGL2D::Flag{}> void renderSinglePixelTextured2D();
template<FlatGL3D::Flag flag = FlatGL3D::Flag{}> void renderSinglePixelTextured3D();
template<FlatGL2D::Flag flag = FlatGL2D::Flag{}> void renderTextured2D();
template<FlatGL3D::Flag flag = FlatGL3D::Flag{}> void renderTextured3D();
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
template<class T, FlatGL2D::Flag flag = FlatGL2D::Flag{}> void renderVertexColor2D();
template<class T, FlatGL3D::Flag flag = FlatGL3D::Flag{}> void renderVertexColor3D();
Shaders: vertex color support in Phong and Flat.
7 years ago
Shaders: rendering tests for Flat shader.
7 years ago
void renderAlphaSetup();
void renderAlphaTeardown();
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag = FlatGL2D::Flag{}> void renderAlpha2D();
template<FlatGL3D::Flag flag = FlatGL3D::Flag{}> void renderAlpha3D();
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
void renderObjectIdSetup();
void renderObjectIdTeardown();
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag = FlatGL2D::Flag{}> void renderObjectId2D();
template<FlatGL3D::Flag flag = FlatGL3D::Flag{}> void renderObjectId3D();
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag = FlatGL2D::Flag{}> void renderInstanced2D();
template<FlatGL3D::Flag flag = FlatGL3D::Flag{}> void renderInstanced3D();
#ifndef MAGNUM_TARGET_GLES2
void renderMulti2D();
void renderMulti3D();
#endif
Shaders: implement instancing in Flat.
6 years ago
Shaders: rendering tests for Flat shader.
7 years ago
private:
PluginManager::Manager<Trade::AbstractImporter> _manager{"nonexistent"};
Fixed shaders tests for iOS
7 years ago
std::string _testDir;
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: whoops, a leftover after pruning depth test from the tests.
7 years ago
GL::Renderbuffer _color{NoCreate};
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
GL::Renderbuffer _objectId{NoCreate};
#endif
Shaders: rendering tests for Flat shader.
7 years ago
GL::Framebuffer _framebuffer{NoCreate};
Shaders: test compilation of Flat and VertexColor shaders.
13 years ago
};
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
/*
Shaders: update notes about what platforms got tested. Besides expanding the tested platform set and updating thresholds where needed, it makes more sense to list what is tested than what is not, because when I forget to update the list it looks like I tested while I did not.
5 years ago
Rendering tests done:
[B] base
[A] alpha mask
[D] object ID
[I] instancing
Shaders: multidraw support in all builtin shaders.
5 years ago
[O] UBOs + draw offset
[M] multidraw
Shaders: update notes about what platforms got tested. Besides expanding the tested platform set and updating thresholds where needed, it makes more sense to list what is tested than what is not, because when I forget to update the list it looks like I tested while I did not.
5 years ago
Shaders: multidraw support in all builtin shaders.
5 years ago
Mesa Intel BADIOM
ES2 xx
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
ES3 BAD Ox
Mesa AMD BAD
Mesa llvmpipe BAD
SwiftShader ES2 BAD xx
ES3 BAD
Shaders: multidraw support in all builtin shaders.
5 years ago
ANGLE ES2 xx
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
ES3 BAD OM
Shaders: multidraw support in all builtin shaders.
5 years ago
ARM Mali (Huawei P10) ES2 BAD xx
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
ES3 BAD Ox
Shaders: multidraw support in all builtin shaders.
5 years ago
WebGL (on Mesa Intel) 1.0 BAD xx
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
2.0 BAD OM
Shaders: update notes about what platforms got tested. Besides expanding the tested platform set and updating thresholds where needed, it makes more sense to list what is tested than what is not, because when I forget to update the list it looks like I tested while I did not.
5 years ago
NVidia BAD
Intel Windows BAD
AMD macOS BAD
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
Intel macOS BAD Ox
Shaders: multidraw support in all builtin shaders.
5 years ago
iPhone 6 w/ iOS 12.4 ES3 BAD x
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
*/
Shaders: rendering tests for Flat shader.
7 years ago
using namespace Math::Literals;
Shaders: simplify Flat shader test.
8 years ago
constexpr struct {
const char* name;
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL2D::Flags flags;
Shaders: simplify Flat shader test.
8 years ago
} ConstructData[]{
{"", {}},
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
{"textured", FlatGL2D::Flag::Textured},
{"textured + texture transformation", FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation},
{"alpha mask", FlatGL2D::Flag::AlphaMask},
{"alpha mask + textured", FlatGL2D::Flag::AlphaMask|FlatGL2D::Flag::Textured},
{"vertex colors", FlatGL2D::Flag::VertexColor},
{"vertex colors + textured", FlatGL2D::Flag::VertexColor|FlatGL2D::Flag::Textured},
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
{"object ID", FlatGL2D::Flag::ObjectId},
{"instanced object ID", FlatGL2D::Flag::InstancedObjectId},
{"object ID + alpha mask + textured", FlatGL2D::Flag::ObjectId|FlatGL2D::Flag::AlphaMask|FlatGL2D::Flag::Textured},
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
{"instanced transformation", FlatGL2D::Flag::InstancedTransformation},
{"instanced texture offset", FlatGL2D::Flag::Textured|FlatGL2D::Flag::InstancedTextureOffset}
Shaders: simplify Flat shader test.
8 years ago
};
Shaders: test compilation of Flat and VertexColor shaders.
13 years ago
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
constexpr struct {
const char* name;
FlatGL2D::Flags flags;
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
UnsignedInt materialCount, drawCount;
Shaders: add UBO support to all shaders.
5 years ago
} ConstructUniformBuffersData[]{
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
{"classic fallback", {}, 1, 1},
{"", FlatGL2D::Flag::UniformBuffers, 1, 1},
/* SwiftShader has 256 uniform vectors at most, per-draw is 4+1 in 3D case
and 3+1 in 2D, per-material 2 */
{"multiple materials, draws", FlatGL2D::Flag::UniformBuffers, 8, 48},
Shaders: expand Flat UBO construction tests a bit.
5 years ago
{"textured", FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::Textured, 1, 1},
{"textured + texture transformation", FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation, 1, 1},
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
{"alpha mask", FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::AlphaMask, 1, 1},
{"object ID", FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::ObjectId, 1, 1},
{"multidraw with all the things", FlatGL2D::Flag::MultiDraw|FlatGL2D::Flag::TextureTransformation|FlatGL2D::Flag::Textured|FlatGL2D::Flag::AlphaMask|FlatGL2D::Flag::ObjectId|FlatGL2D::Flag::InstancedTextureOffset|FlatGL2D::Flag::InstancedTransformation|FlatGL2D::Flag::InstancedObjectId, 8, 48}
};
#endif
#ifndef MAGNUM_TARGET_GLES2
constexpr struct {
const char* name;
FlatGL2D::Flags flags;
UnsignedInt materialCount, drawCount;
const char* message;
} ConstructUniformBuffersInvalidData[]{
{"zero draws", FlatGL2D::Flag::UniformBuffers, 1, 0,
"draw count can't be zero"},
{"zero materials", FlatGL2D::Flag::UniformBuffers, 0, 1,
"material count can't be zero"},
Shaders: add UBO support to all shaders.
5 years ago
};
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
const struct {
const char* name;
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL2D::Flags flags;
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Matrix3 textureTransformation;
bool flip;
} RenderTexturedData[]{
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
{"", FlatGL2D::Flag::Textured, {}, false},
Shaders: grumble.
6 years ago
{"texture transformation",
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation,
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Matrix3::translation(Vector2{1.0f})*Matrix3::scaling(Vector2{-1.0f}),
true},
};
Shaders: rendering tests for Flat shader.
7 years ago
const struct {
const char* name;
const char* expected2D;
const char* expected3D;
bool blending;
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL2D::Flags flags;
Shaders: rendering tests for Flat shader.
7 years ago
Float threshold;
} RenderAlphaData[] {
/* All those deliberately have a non-white diffuse in order to match the
expected data from textured() */
{"none", "FlatTestFiles/textured2D.tga", "FlatTestFiles/textured3D.tga", false,
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL2D::Flag::Textured, 0.0f},
Shaders: rendering tests for Flat shader.
7 years ago
{"blending", "FlatTestFiles/textured2D-alpha.tga", "FlatTestFiles/textured3D-alpha.tga", true,
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL2D::Flag::Textured, 0.0f},
Shaders: rendering tests for Flat shader.
7 years ago
{"masking 0.0", "FlatTestFiles/textured2D.tga", "FlatTestFiles/textured3D.tga", false,
Shaders: this accidentally didn't actually test the thing. ...but was the same as the "blending" case above. Fortunately there was no bug hidden underneath.
5 years ago
FlatGL2D::Flag::Textured|FlatGL2D::Flag::AlphaMask, 0.0f},
Shaders: rendering tests for Flat shader.
7 years ago
{"masking 0.5", "FlatTestFiles/textured2D-alpha-mask0.5.tga", "FlatTestFiles/textured3D-alpha-mask0.5.tga", false,
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL2D::Flag::Textured|FlatGL2D::Flag::AlphaMask, 0.5f},
Shaders: rendering tests for Flat shader.
7 years ago
{"masking 1.0", "TestFiles/alpha-mask1.0.tga", "TestFiles/alpha-mask1.0.tga", false,
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL2D::Flag::Textured|FlatGL2D::Flag::AlphaMask, 1.0f}
Shaders: rendering tests for Flat shader.
7 years ago
};
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
constexpr struct {
const char* name;
const char* expected2D;
const char* expected3D;
FlatGL2D::Flags flags;
Float maxThreshold, meanThreshold;
} RenderInstancedData[] {
{"colored", "instanced2D.tga", "instanced3D.tga",
{},
/* Minor differences on SwiftShader */
164.4f, 0.094f},
{"textured", "instanced-textured2D.tga", "instanced-textured3D.tga",
FlatGL2D::Flag::InstancedTextureOffset|FlatGL2D::Flag::Textured,
/* Minor differences on SwiftShader */
192.67f, 0.140f},
};
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
constexpr struct {
const char* name;
const char* expected2D;
const char* expected3D;
FlatGL2D::Flags flags;
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
UnsignedInt materialCount, drawCount;
Shaders: add UBO support to all shaders.
5 years ago
UnsignedInt uniformIncrement;
Float maxThreshold, meanThreshold;
} RenderMultiData[] {
{"bind with offset, colored", "multidraw2D.tga", "multidraw3D.tga",
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
{}, 1, 1, 16, 0.0f, 0.0f},
Shaders: add UBO support to all shaders.
5 years ago
{"bind with offset, textured", "multidraw-textured2D.tga", "multidraw-textured3D.tga",
FlatGL2D::Flag::TextureTransformation|FlatGL2D::Flag::Textured,
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
1, 1, 16,
Shaders: update notes about what platforms got tested. Besides expanding the tested platform set and updating thresholds where needed, it makes more sense to list what is tested than what is not, because when I forget to update the list it looks like I tested while I did not.
5 years ago
/* Minor differences on ARM Mali */
2.34f, 0.01f},
Shaders: add UBO support to all shaders.
5 years ago
{"draw offset, colored", "multidraw2D.tga", "multidraw3D.tga",
Shaders: multidraw support in all builtin shaders.
5 years ago
{},
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
2, 3, 1, 0.0f, 0.0f},
Shaders: add UBO support to all shaders.
5 years ago
{"draw offset, textured", "multidraw-textured2D.tga", "multidraw-textured3D.tga",
FlatGL2D::Flag::TextureTransformation|FlatGL2D::Flag::Textured,
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
2, 3, 1,
Shaders: update notes about what platforms got tested. Besides expanding the tested platform set and updating thresholds where needed, it makes more sense to list what is tested than what is not, because when I forget to update the list it looks like I tested while I did not.
5 years ago
/* Minor differences on ARM Mali */
Shaders: multidraw support in all builtin shaders.
5 years ago
2.34f, 0.01f},
{"multidraw, colored", "multidraw2D.tga", "multidraw3D.tga",
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
FlatGL2D::Flag::MultiDraw, 2, 3, 1, 0.0f, 0.0f},
Shaders: multidraw support in all builtin shaders.
5 years ago
{"multidraw, textured", "multidraw-textured2D.tga", "multidraw-textured3D.tga",
FlatGL2D::Flag::MultiDraw|FlatGL2D::Flag::TextureTransformation|FlatGL2D::Flag::Textured,
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
2, 3, 1,
Shaders: multidraw support in all builtin shaders.
5 years ago
/* Minor differences on ARM Mali */
Shaders: update notes about what platforms got tested. Besides expanding the tested platform set and updating thresholds where needed, it makes more sense to list what is tested than what is not, because when I forget to update the list it looks like I tested while I did not.
5 years ago
2.34f, 0.01f}
Shaders: add UBO support to all shaders.
5 years ago
};
#endif
Shaders: simplify Flat shader test.
8 years ago
FlatGLTest::FlatGLTest() {
addInstancedTests<FlatGLTest>({
&FlatGLTest::construct<2>,
&FlatGLTest::construct<3>},
Containers::arraySize(ConstructData));
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
addInstancedTests<FlatGLTest>({
&FlatGLTest::constructUniformBuffers<2>,
&FlatGLTest::constructUniformBuffers<3>},
Containers::arraySize(ConstructUniformBuffersData));
#endif
Shaders: simplify Flat shader test.
8 years ago
addTests<FlatGLTest>({
&FlatGLTest::constructMove<2>,
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
&FlatGLTest::constructMove<3>,
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::constructMoveUniformBuffers<2>,
&FlatGLTest::constructMoveUniformBuffers<3>,
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
&FlatGLTest::constructTextureTransformationNotTextured<2>,
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
&FlatGLTest::constructTextureTransformationNotTextured<3>});
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
addInstancedTests<FlatGLTest>({
&FlatGLTest::constructUniformBuffersInvalid<2>,
&FlatGLTest::constructUniformBuffersInvalid<3>},
Containers::arraySize(ConstructUniformBuffersInvalidData));
#endif
addTests<FlatGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::setUniformUniformBuffersEnabled<2>,
&FlatGLTest::setUniformUniformBuffersEnabled<3>,
&FlatGLTest::bindBufferUniformBuffersNotEnabled<2>,
&FlatGLTest::bindBufferUniformBuffersNotEnabled<3>,
#endif
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
&FlatGLTest::bindTextureNotEnabled<2>,
Shaders: classical alpha masking support in Phong and Flat. Slow and ugly, is here only for making quick'n'dirty alpha masked drawing without a need for blending or depth sorting. Oh and also to support the glTF alpha mask feature. Again, beware: *slow*.
8 years ago
&FlatGLTest::bindTextureNotEnabled<3>,
&FlatGLTest::setAlphaMaskNotEnabled<2>,
Shaders: support object ID output in Flat and Phong.
7 years ago
&FlatGLTest::setAlphaMaskNotEnabled<3>,
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
&FlatGLTest::setTextureMatrixNotEnabled<2>,
&FlatGLTest::setTextureMatrixNotEnabled<3>,
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: add UBO support to all shaders.
5 years ago
&FlatGLTest::bindTextureTransformBufferNotEnabled<2>,
&FlatGLTest::bindTextureTransformBufferNotEnabled<3>,
#endif
#ifndef MAGNUM_TARGET_GLES2
Shaders: support object ID output in Flat and Phong.
7 years ago
&FlatGLTest::setObjectIdNotEnabled<2>,
Shaders: add UBO support to all shaders.
5 years ago
&FlatGLTest::setObjectIdNotEnabled<3>,
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::setWrongDrawOffset<2>,
&FlatGLTest::setWrongDrawOffset<3>,
#endif
});
Shaders: a crutch for MSVC's neverending fails. Hope this is enough?
5 years ago
/* MSVC needs explicit type due to default template args */
addTests<FlatGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&FlatGLTest::renderDefaults2D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderDefaults2D<FlatGL2D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderDefaults3D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderDefaults3D<FlatGL3D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderColored2D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderColored2D<FlatGL2D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderColored3D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderColored3D<FlatGL3D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderSinglePixelTextured2D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderSinglePixelTextured2D<FlatGL2D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderSinglePixelTextured3D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderSinglePixelTextured3D<FlatGL2D::Flag::UniformBuffers>
#endif
},
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
&FlatGLTest::renderSetup,
&FlatGLTest::renderTeardown);
Shaders: a crutch for MSVC's neverending fails. Hope this is enough?
5 years ago
/* MSVC needs explicit type due to default template args */
addInstancedTests<FlatGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&FlatGLTest::renderTextured2D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderTextured2D<FlatGL2D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderTextured3D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderTextured3D<FlatGL3D::Flag::UniformBuffers>
#endif
},
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Containers::arraySize(RenderTexturedData),
&FlatGLTest::renderSetup,
&FlatGLTest::renderTeardown);
Shaders: a crutch for MSVC's neverending fails. Hope this is enough?
5 years ago
/* MSVC needs explicit type due to default template args */
addTests<FlatGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&FlatGLTest::renderVertexColor2D<Color3>,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderVertexColor2D<Color3, FlatGL2D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderVertexColor2D<Color4>,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderVertexColor2D<Color4, FlatGL2D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderVertexColor3D<Color3>,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderVertexColor3D<Color3, FlatGL3D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderVertexColor3D<Color4>,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderVertexColor3D<Color4, FlatGL3D::Flag::UniformBuffers>
#endif
},
Shaders: rendering tests for Flat shader.
7 years ago
&FlatGLTest::renderSetup,
&FlatGLTest::renderTeardown);
Shaders: a crutch for MSVC's neverending fails. Hope this is enough?
5 years ago
/* MSVC needs explicit type due to default template args */
addInstancedTests<FlatGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&FlatGLTest::renderAlpha2D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderAlpha2D<FlatGL2D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderAlpha3D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderAlpha3D<FlatGL3D::Flag::UniformBuffers>
#endif
},
Shaders: rendering tests for Flat shader.
7 years ago
Containers::arraySize(RenderAlphaData),
&FlatGLTest::renderAlphaSetup,
&FlatGLTest::renderAlphaTeardown);
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: a crutch for MSVC's neverending fails. Hope this is enough?
5 years ago
/* MSVC needs explicit type due to default template args */
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
addTests<FlatGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&FlatGLTest::renderObjectId2D,
&FlatGLTest::renderObjectId2D<FlatGL2D::Flag::UniformBuffers>,
&FlatGLTest::renderObjectId3D,
&FlatGLTest::renderObjectId3D<FlatGL3D::Flag::UniformBuffers>},
Shaders: support object ID output in Flat and Phong.
7 years ago
&FlatGLTest::renderObjectIdSetup,
&FlatGLTest::renderObjectIdTeardown);
#endif
Shaders: a crutch for MSVC's neverending fails. Hope this is enough?
5 years ago
/* MSVC needs explicit type due to default template args */
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
addInstancedTests<FlatGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&FlatGLTest::renderInstanced2D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderInstanced2D<FlatGL2D::Flag::UniformBuffers>,
#endif
&FlatGLTest::renderInstanced3D,
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderInstanced3D<FlatGL3D::Flag::UniformBuffers>
#endif
},
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
Containers::arraySize(RenderInstancedData),
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
#ifndef MAGNUM_TARGET_GLES2
&FlatGLTest::renderObjectIdSetup,
&FlatGLTest::renderObjectIdTeardown
#else
Shaders: implement instancing in Flat.
6 years ago
&FlatGLTest::renderSetup,
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
&FlatGLTest::renderTeardown
#endif
);
Shaders: implement instancing in Flat.
6 years ago
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
addInstancedTests({&FlatGLTest::renderMulti2D,
&FlatGLTest::renderMulti3D},
Containers::arraySize(RenderMultiData),
&FlatGLTest::renderObjectIdSetup,
&FlatGLTest::renderObjectIdTeardown);
#endif
Shaders: rendering tests for Flat shader.
7 years ago
/* Load the plugins directly from the build tree. Otherwise they're either
static and already loaded or not present in the build tree */
#ifdef ANYIMAGEIMPORTER_PLUGIN_FILENAME
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(_manager.load(ANYIMAGEIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
Shaders: rendering tests for Flat shader.
7 years ago
#endif
#ifdef TGAIMPORTER_PLUGIN_FILENAME
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(_manager.load(TGAIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
Shaders: rendering tests for Flat shader.
7 years ago
#endif
Fixed shaders tests for iOS
7 years ago
#ifdef CORRADE_TARGET_APPLE
if(Utility::Directory::isSandboxed()
#if defined(CORRADE_TARGET_IOS) && defined(CORRADE_TESTSUITE_TARGET_XCTEST)
/** @todo Fix this once I persuade CMake to run XCTest tests properly */
&& std::getenv("SIMULATOR_UDID")
#endif
) {
_testDir = Utility::Directory::path(Utility::Directory::executableLocation());
} else
#endif
{
_testDir = SHADERS_TEST_DIR;
}
Shaders: test compilation of Flat and VertexColor shaders.
13 years ago
}
Shaders: simplify Flat shader test.
8 years ago
template<UnsignedInt dimensions> void FlatGLTest::construct() {
Test: use the new setTestCaseTemplateName().
7 years ago
setTestCaseTemplateName(std::to_string(dimensions));
Shaders: simplify Flat shader test.
8 years ago
auto&& data = ConstructData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: textured version of Flat shader.
13 years ago
Test: most tests now pass on Zink as well. Just adding a bunch of extension checks that I thought I would never need again.
6 years ago
#ifndef MAGNUM_TARGET_GLES
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
if((data.flags & FlatGL2D::Flag::ObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
Test: most tests now pass on Zink as well. Just adding a bunch of extension checks that I thought I would never need again.
6 years ago
#endif
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL<dimensions> shader{data.flags};
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
CORRADE_COMPARE(shader.flags(), data.flags);
Shaders: no, these are not expected to fail on macOS.
7 years ago
CORRADE_VERIFY(shader.id());
Don't do shader validation in GL tests on OSX. Apple wants insane amount of state to return true (bound FB, bound VAO, etc.). Ugh.
10 years ago
{
#ifdef CORRADE_TARGET_APPLE
Consistently use macOS instead of OSX.
9 years ago
CORRADE_EXPECT_FAIL("macOS drivers need insane amount of state to validate properly.");
Don't do shader validation in GL tests on OSX. Apple wants insane amount of state to return true (bound FB, bound VAO, etc.). Ugh.
10 years ago
#endif
CORRADE_VERIFY(shader.validate().first);
}
Shaders: verify that no GL errors happened during construction.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: textured version of Flat shader.
13 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffers() {
setTestCaseTemplateName(std::to_string(dimensions));
auto&& data = ConstructUniformBuffersData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if((data.flags & FlatGL2D::Flag::UniformBuffers) && !GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
if((data.flags & FlatGL2D::Flag::ObjectId) && !GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
#endif
Shaders: multidraw support in all builtin shaders.
5 years ago
if(data.flags >= FlatGL2D::Flag::MultiDraw) {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::shader_draw_parameters>())
CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported.");
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::multi_draw>())
CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported.");
#else
if(!GL::Context::current().isExtensionSupported<GL::Extensions::WEBGL::multi_draw>())
CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported.");
#endif
}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
FlatGL<dimensions> shader{data.flags, data.materialCount, data.drawCount};
Shaders: add UBO support to all shaders.
5 years ago
CORRADE_COMPARE(shader.flags(), data.flags);
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
CORRADE_COMPARE(shader.materialCount(), data.materialCount);
Shaders: add UBO support to all shaders.
5 years ago
CORRADE_COMPARE(shader.drawCount(), data.drawCount);
CORRADE_VERIFY(shader.id());
{
#ifdef CORRADE_TARGET_APPLE
CORRADE_EXPECT_FAIL("macOS drivers need insane amount of state to validate properly.");
#endif
CORRADE_VERIFY(shader.validate().first);
}
MAGNUM_VERIFY_NO_GL_ERROR();
}
#endif
Shaders: simplify Flat shader test.
8 years ago
template<UnsignedInt dimensions> void FlatGLTest::constructMove() {
Test: use the new setTestCaseTemplateName().
7 years ago
setTestCaseTemplateName(std::to_string(dimensions));
Shaders: improve copy/move construction tests. Doesn't compile at the moment because AbstractVector has a private constructor and so the move constructors are not generated or something.
8 years ago
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL<dimensions> a{FlatGL<dimensions>::Flag::Textured};
Shaders: improve copy/move construction tests. Doesn't compile at the moment because AbstractVector has a private constructor and so the move constructors are not generated or something.
8 years ago
const GLuint id = a.id();
CORRADE_VERIFY(id);
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL<dimensions> b{std::move(a)};
Shaders: improve copy/move construction tests. Doesn't compile at the moment because AbstractVector has a private constructor and so the move constructors are not generated or something.
8 years ago
CORRADE_COMPARE(b.id(), id);
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
CORRADE_COMPARE(b.flags(), FlatGL<dimensions>::Flag::Textured);
Shaders: improve copy/move construction tests. Doesn't compile at the moment because AbstractVector has a private constructor and so the move constructors are not generated or something.
8 years ago
CORRADE_VERIFY(!a.id());
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL<dimensions> c{NoCreate};
Shaders: improve copy/move construction tests. Doesn't compile at the moment because AbstractVector has a private constructor and so the move constructors are not generated or something.
8 years ago
c = std::move(b);
CORRADE_COMPARE(c.id(), id);
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
CORRADE_COMPARE(c.flags(), FlatGL<dimensions>::Flag::Textured);
Shaders: improve copy/move construction tests. Doesn't compile at the moment because AbstractVector has a private constructor and so the move constructors are not generated or something.
8 years ago
CORRADE_VERIFY(!b.id());
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void FlatGLTest::constructMoveUniformBuffers() {
setTestCaseTemplateName(std::to_string(dimensions));
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
FlatGL<dimensions> a{FlatGL<dimensions>::Flag::UniformBuffers, 2, 5};
Shaders: add UBO support to all shaders.
5 years ago
const GLuint id = a.id();
CORRADE_VERIFY(id);
MAGNUM_VERIFY_NO_GL_ERROR();
FlatGL<dimensions> b{std::move(a)};
CORRADE_COMPARE(b.id(), id);
CORRADE_COMPARE(b.flags(), FlatGL<dimensions>::Flag::UniformBuffers);
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
CORRADE_COMPARE(b.materialCount(), 2);
Shaders: add UBO support to all shaders.
5 years ago
CORRADE_COMPARE(b.drawCount(), 5);
CORRADE_VERIFY(!a.id());
FlatGL<dimensions> c{NoCreate};
c = std::move(b);
CORRADE_COMPARE(c.id(), id);
CORRADE_COMPARE(c.flags(), FlatGL<dimensions>::Flag::UniformBuffers);
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
CORRADE_COMPARE(c.materialCount(), 2);
Shaders: add UBO support to all shaders.
5 years ago
CORRADE_COMPARE(c.drawCount(), 5);
CORRADE_VERIFY(!b.id());
}
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
template<UnsignedInt dimensions> void FlatGLTest::constructTextureTransformationNotTextured() {
setTestCaseTemplateName(std::to_string(dimensions));
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
std::ostringstream out;
Error redirectError{&out};
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL<dimensions>{FlatGL<dimensions>::Flag::TextureTransformation};
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
CORRADE_COMPARE(out.str(),
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
"Shaders::FlatGL: texture transformation enabled but the shader is not textured\n");
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
template<UnsignedInt dimensions> void FlatGLTest::constructUniformBuffersInvalid() {
auto&& data = ConstructUniformBuffersInvalidData[testCaseInstanceId()];
Shaders: add UBO support to all shaders.
5 years ago
setTestCaseTemplateName(std::to_string(dimensions));
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
std::ostringstream out;
Error redirectError{&out};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
FlatGL<dimensions>{data.flags, data.materialCount, data.drawCount};
CORRADE_COMPARE(out.str(), Utility::formatString(
"Shaders::FlatGL: {}\n", data.message));
Shaders: add UBO support to all shaders.
5 years ago
}
#endif
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void FlatGLTest::setUniformUniformBuffersEnabled() {
setTestCaseTemplateName(std::to_string(dimensions));
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
std::ostringstream out;
Error redirectError{&out};
FlatGL<dimensions> shader{FlatGL<dimensions>::Flag::UniformBuffers};
shader.setTransformationProjectionMatrix({})
.setTextureMatrix({})
.setColor({})
.setAlphaMask({})
.setObjectId({});
CORRADE_COMPARE(out.str(),
"Shaders::FlatGL::setTransformationProjectionMatrix(): the shader was created with uniform buffers enabled\n"
"Shaders::FlatGL::setTextureMatrix(): the shader was created with uniform buffers enabled\n"
"Shaders::FlatGL::setColor(): the shader was created with uniform buffers enabled\n"
"Shaders::FlatGL::setAlphaMask(): the shader was created with uniform buffers enabled\n"
"Shaders::FlatGL::setObjectId(): the shader was created with uniform buffers enabled\n");
}
template<UnsignedInt dimensions> void FlatGLTest::bindBufferUniformBuffersNotEnabled() {
setTestCaseTemplateName(std::to_string(dimensions));
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
std::ostringstream out;
Error redirectError{&out};
GL::Buffer buffer;
FlatGL<dimensions> shader;
shader.bindTransformationProjectionBuffer(buffer)
.bindTransformationProjectionBuffer(buffer, 0, 16)
.bindDrawBuffer(buffer)
.bindDrawBuffer(buffer, 0, 16)
.bindTextureTransformationBuffer(buffer)
.bindTextureTransformationBuffer(buffer, 0, 16)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(buffer)
.bindMaterialBuffer(buffer, 0, 16)
Shaders: add UBO support to all shaders.
5 years ago
.setDrawOffset(0);
CORRADE_COMPARE(out.str(),
"Shaders::FlatGL::bindTransformationProjectionBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::FlatGL::bindTransformationProjectionBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::FlatGL::bindDrawBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::FlatGL::bindDrawBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::FlatGL::bindTextureTransformationBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::FlatGL::bindTextureTransformationBuffer(): the shader was not created with uniform buffers enabled\n"
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
"Shaders::FlatGL::bindMaterialBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::FlatGL::bindMaterialBuffer(): the shader was not created with uniform buffers enabled\n"
Shaders: add UBO support to all shaders.
5 years ago
"Shaders::FlatGL::setDrawOffset(): the shader was not created with uniform buffers enabled\n");
}
#endif
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
template<UnsignedInt dimensions> void FlatGLTest::bindTextureNotEnabled() {
Test: use the new setTestCaseTemplateName().
7 years ago
setTestCaseTemplateName(std::to_string(dimensions));
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
std::ostringstream out;
Error redirectError{&out};
GL::Texture2D texture;
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL<dimensions> shader;
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
shader.bindTexture(texture);
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
CORRADE_COMPARE(out.str(), "Shaders::FlatGL::bindTexture(): the shader was not created with texturing enabled\n");
Shaders: assert texturing is enabled when calling Flat::bindTexture().
8 years ago
}
Shaders: classical alpha masking support in Phong and Flat. Slow and ugly, is here only for making quick'n'dirty alpha masked drawing without a need for blending or depth sorting. Oh and also to support the glTF alpha mask feature. Again, beware: *slow*.
8 years ago
template<UnsignedInt dimensions> void FlatGLTest::setAlphaMaskNotEnabled() {
Test: use the new setTestCaseTemplateName().
7 years ago
setTestCaseTemplateName(std::to_string(dimensions));
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Shaders: classical alpha masking support in Phong and Flat. Slow and ugly, is here only for making quick'n'dirty alpha masked drawing without a need for blending or depth sorting. Oh and also to support the glTF alpha mask feature. Again, beware: *slow*.
8 years ago
std::ostringstream out;
Error redirectError{&out};
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL<dimensions> shader;
Shaders: classical alpha masking support in Phong and Flat. Slow and ugly, is here only for making quick'n'dirty alpha masked drawing without a need for blending or depth sorting. Oh and also to support the glTF alpha mask feature. Again, beware: *slow*.
8 years ago
shader.setAlphaMask(0.75f);
CORRADE_COMPARE(out.str(),
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
"Shaders::FlatGL::setAlphaMask(): the shader was not created with alpha mask enabled\n");
Shaders: classical alpha masking support in Phong and Flat. Slow and ugly, is here only for making quick'n'dirty alpha masked drawing without a need for blending or depth sorting. Oh and also to support the glTF alpha mask feature. Again, beware: *slow*.
8 years ago
}
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
template<UnsignedInt dimensions> void FlatGLTest::setTextureMatrixNotEnabled() {
setTestCaseTemplateName(std::to_string(dimensions));
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
std::ostringstream out;
Error redirectError{&out};
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL<dimensions> shader;
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
shader.setTextureMatrix({});
CORRADE_COMPARE(out.str(),
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
"Shaders::FlatGL::setTextureMatrix(): the shader was not created with texture transformation enabled\n");
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void FlatGLTest::bindTextureTransformBufferNotEnabled() {
setTestCaseTemplateName(std::to_string(dimensions));
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
std::ostringstream out;
Error redirectError{&out};
GL::Buffer buffer{GL::Buffer::TargetHint::Uniform};
FlatGL<dimensions> shader{FlatGL<dimensions>::Flag::UniformBuffers};
shader.bindTextureTransformationBuffer(buffer)
.bindTextureTransformationBuffer(buffer, 0, 16);
CORRADE_COMPARE(out.str(),
"Shaders::FlatGL::bindTextureTransformationBuffer(): the shader was not created with texture transformation enabled\n"
"Shaders::FlatGL::bindTextureTransformationBuffer(): the shader was not created with texture transformation enabled\n");
}
#endif
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void FlatGLTest::setObjectIdNotEnabled() {
setTestCaseTemplateName(std::to_string(dimensions));
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Shaders: support object ID output in Flat and Phong.
7 years ago
std::ostringstream out;
Error redirectError{&out};
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL<dimensions> shader;
Shaders: support object ID output in Flat and Phong.
7 years ago
shader.setObjectId(33376);
CORRADE_COMPARE(out.str(),
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
"Shaders::FlatGL::setObjectId(): the shader was not created with object ID enabled\n");
Shaders: support object ID output in Flat and Phong.
7 years ago
}
#endif
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> void FlatGLTest::setWrongDrawOffset() {
setTestCaseTemplateName(std::to_string(dimensions));
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
std::ostringstream out;
Error redirectError{&out};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
FlatGL<dimensions>{FlatGL<dimensions>::Flag::UniformBuffers, 2, 5}
Shaders: add UBO support to all shaders.
5 years ago
.setDrawOffset(5);
CORRADE_COMPARE(out.str(),
"Shaders::FlatGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
constexpr Vector2i RenderSize{80, 80};
void FlatGLTest::renderSetup() {
/* Pick a color that's directly representable on RGBA4 as well to reduce
artifacts */
GL::Renderer::setClearColor(0x111111_rgbf);
GL::Renderer::enable(GL::Renderer::Feature::FaceCulling);
_color = GL::Renderbuffer{};
_color.setStorage(
#if !defined(MAGNUM_TARGET_GLES2) || !defined(MAGNUM_TARGET_WEBGL)
GL::RenderbufferFormat::RGBA8,
#else
GL::RenderbufferFormat::RGBA4,
#endif
RenderSize);
_framebuffer = GL::Framebuffer{{{}, RenderSize}};
_framebuffer.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, _color)
.clear(GL::FramebufferClear::Color)
.bind();
}
void FlatGLTest::renderTeardown() {
_framebuffer = GL::Framebuffer{NoCreate};
Shaders: destruct test scaffolding in reverse order.
7 years ago
_color = GL::Renderbuffer{NoCreate};
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag> void FlatGLTest::renderDefaults2D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32));
Shaders: add UBO support to all shaders.
5 years ago
FlatGL2D shader{flag};
if(flag == FlatGL2D::Flag{}) {
shader.draw(circle);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform2D{}
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
}};
Shaders: add UBO support to all shaders.
5 years ago
shader
.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(circle);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/defaults.tga"),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
/* SwiftShader has 8 different pixels on the edges */
(DebugTools::CompareImageToFile{_manager, 238.0f, 0.2975f}));
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL3D::Flag flag> void FlatGLTest::renderDefaults3D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL3D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
Shaders: add UBO support to all shaders.
5 years ago
FlatGL3D shader{flag};
if(flag == FlatGL3D::Flag{}) {
shader.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL3D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform3D{}
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
}};
Shaders: add UBO support to all shaders.
5 years ago
shader
.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/defaults.tga"),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
/* SwiftShader has 8 different pixels on the edges */
(DebugTools::CompareImageToFile{_manager, 238.0f, 0.2975f}));
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag> void FlatGLTest::renderColored2D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32));
Shaders: add UBO support to all shaders.
5 years ago
FlatGL2D shader{flag};
if(flag == FlatGL2D::Flag{}) {
shader
.setColor(0x9999ff_rgbf)
.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
.draw(circle);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
Shaders: add UBO support to all shaders.
5 years ago
.setColor(0x9999ff_rgbf)
}};
shader
.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(circle);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
const Float maxThreshold = 0.0f, meanThreshold = 0.0f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 11.34f, meanThreshold = 0.51f;
#endif
Shaders: rendering tests for Flat shader.
7 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/colored2D.tga"),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL3D::Flag flag> void FlatGLTest::renderColored3D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL3D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
Shaders: add UBO support to all shaders.
5 years ago
FlatGL3D shader{flag};
if(flag == FlatGL3D::Flag{}) {
shader
.setColor(0x9999ff_rgbf)
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf))
.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL3D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
Shaders: add UBO support to all shaders.
5 years ago
.setColor(0x9999ff_rgbf)
}};
shader
.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has 5 different pixels on the edges */
const Float maxThreshold = 170.0f, meanThreshold = 0.133f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 170.0f, meanThreshold = 0.456f;
#endif
Shaders: rendering tests for Flat shader.
7 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/colored3D.tga"),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Flat shader.
7 years ago
}
constexpr GL::TextureFormat TextureFormatRGB =
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
GL::TextureFormat::RGB8
#else
GL::TextureFormat::RGB
#endif
;
constexpr GL::TextureFormat TextureFormatRGBA =
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
GL::TextureFormat::RGBA8
#else
GL::TextureFormat::RGBA
#endif
;
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag> void FlatGLTest::renderSinglePixelTextured2D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32,
Primitives: switch to an enum set for texturable primitives. Making room for GenerateTangents in 3D, and keeping the 2D ones consistent with 3D. Also renamed GenerateTextureCoords to GenerateTextureCoordinates in the remaining places to be consistent with naming in the rest of the APIs.
6 years ago
Primitives::Circle2DFlag::TextureCoordinates));
Shaders: rendering tests for Flat shader.
7 years ago
const Color4ub diffuseData[]{ 0x9999ff_rgb };
ImageView2D diffuseImage{PixelFormat::RGBA8Unorm, Vector2i{1}, diffuseData};
GL::Texture2D texture;
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGBA, Vector2i{1})
.setSubImage(0, {}, diffuseImage);
Shaders: add UBO support to all shaders.
5 years ago
FlatGL2D shader{FlatGL2D::Flag::Textured|flag};
shader.bindTexture(texture);
if(flag == FlatGL2D::Flag{}) {
shader.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
.draw(circle);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
}};
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(circle);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has 5 different pixels on the edges */
const Float maxThreshold = 170.0f, meanThreshold = 0.133f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 11.34f, meanThreshold = 0.51f;
#endif
Shaders: rendering tests for Flat shader.
7 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/colored2D.tga"),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL3D::Flag flag> void FlatGLTest::renderSinglePixelTextured3D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL3D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
Primitives: switch to an enum set for texturable primitives. Making room for GenerateTangents in 3D, and keeping the 2D ones consistent with 3D. Also renamed GenerateTextureCoords to GenerateTextureCoordinates in the remaining places to be consistent with naming in the rest of the APIs.
6 years ago
Primitives::UVSphereFlag::TextureCoordinates));
Shaders: rendering tests for Flat shader.
7 years ago
const Color4ub diffuseData[]{ 0x9999ff_rgb };
ImageView2D diffuseImage{PixelFormat::RGBA8Unorm, Vector2i{1}, diffuseData};
GL::Texture2D texture;
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGBA, Vector2i{1})
.setSubImage(0, {}, diffuseImage);
Shaders: add UBO support to all shaders.
5 years ago
FlatGL3D shader{FlatGL3D::Flag::Textured|flag};
shader.bindTexture(texture);
if(flag == FlatGL3D::Flag{}) {
shader.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL3D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
}};
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has 5 different pixels on the edges */
const Float maxThreshold = 170.0f, meanThreshold = 0.133f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 170.0f, meanThreshold = 0.456f;
#endif
Shaders: rendering tests for Flat shader.
7 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/colored3D.tga"),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag> void FlatGLTest::renderTextured2D() {
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
auto&& data = RenderTexturedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32,
Primitives: switch to an enum set for texturable primitives. Making room for GenerateTangents in 3D, and keeping the 2D ones consistent with 3D. Also renamed GenerateTextureCoords to GenerateTextureCoordinates in the remaining places to be consistent with naming in the rest of the APIs.
6 years ago
Primitives::Circle2DFlag::TextureCoordinates));
Shaders: rendering tests for Flat shader.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
GL::Texture2D texture;
Containers::Optional<Trade::ImageData2D> image;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/diffuse-texture.tga")) && (image = importer->image2D(0)));
Shaders: rendering tests for Flat shader.
7 years ago
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
Shaders: add UBO support to all shaders.
5 years ago
FlatGL2D shader{data.flags|flag};
shader.bindTexture(texture);
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Shaders: add UBO support to all shaders.
5 years ago
if(flag == FlatGL2D::Flag{}) {
if(data.textureTransformation != Matrix3{})
shader.setTextureMatrix(data.textureTransformation);
shader.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
/* Colorized. Case without a color (where it should be white) is
tested in renderSinglePixelTextured2D() */
.setColor(0x9999ff_rgbf)
.draw(circle);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
}};
GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, {
TextureTransformationUniform{}
.setTextureMatrix(data.textureTransformation)
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
.setColor(0x9999ff_rgbf)
}};
Shaders: add UBO support to all shaders.
5 years ago
if(data.flags & FlatGL2D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform);
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(circle);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Image2D rendered = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm});
/* Dropping the alpha channel, as it's always 1.0 */
Containers::StridedArrayView2D<Color3ub> pixels =
Containers::arrayCast<Color3ub>(rendered.pixels<Color4ub>());
if(data.flip) pixels = pixels.flipped<0>().flipped<1>();
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
/* SwiftShader has minor rounding errors, Apple A8 & llvmpipe a bit more */
const Float maxThreshold = 2.334f, meanThreshold = 0.032f;
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 15.667f, meanThreshold = 3.254f;
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
CORRADE_COMPARE_WITH(pixels,
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/textured2D.tga"),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL3D::Flag flag> void FlatGLTest::renderTextured3D() {
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
auto&& data = RenderTexturedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL3D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
Primitives: switch to an enum set for texturable primitives. Making room for GenerateTangents in 3D, and keeping the 2D ones consistent with 3D. Also renamed GenerateTextureCoords to GenerateTextureCoordinates in the remaining places to be consistent with naming in the rest of the APIs.
6 years ago
Primitives::UVSphereFlag::TextureCoordinates));
Shaders: rendering tests for Flat shader.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
GL::Texture2D texture;
Containers::Optional<Trade::ImageData2D> image;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/diffuse-texture.tga")) && (image = importer->image2D(0)));
Shaders: rendering tests for Flat shader.
7 years ago
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
Shaders: add UBO support to all shaders.
5 years ago
FlatGL3D shader{data.flags|flag};
shader.bindTexture(texture);
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Shaders: add UBO support to all shaders.
5 years ago
if(flag == FlatGL3D::Flag{}) {
if(data.textureTransformation != Matrix3{})
shader.setTextureMatrix(data.textureTransformation);
shader
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(data.flip ? 15.0_degf : -15.0_degf)*
Matrix4::rotationX(data.flip ? -15.0_degf : 15.0_degf))
/* Colorized. Case without a color (where it should be white) is
tested in renderSinglePixelTextured3D() */
.setColor(0x9999ff_rgbf)
.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL3D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(data.flip ? 15.0_degf : -15.0_degf)*
Matrix4::rotationX(data.flip ? -15.0_degf : 15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
}};
GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, {
TextureTransformationUniform{}
.setTextureMatrix(data.textureTransformation)
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
.setColor(0x9999ff_rgbf)
}};
Shaders: add UBO support to all shaders.
5 years ago
if(data.flags & FlatGL3D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform);
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Image2D rendered = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm});
/* Dropping the alpha channel, as it's always 1.0 */
Containers::StridedArrayView2D<Color3ub> pixels =
Containers::arrayCast<Color3ub>(rendered.pixels<Color4ub>());
if(data.flip) pixels = pixels.flipped<0>().flipped<1>();
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has 5 different pixels on the edges */
const Float maxThreshold = 139.0f, meanThreshold = 0.087f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 139.0f, meanThreshold = 2.896f;
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
CORRADE_COMPARE_WITH(pixels,
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/textured3D.tga"),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<class T, FlatGL2D::Flag flag> void FlatGLTest::renderVertexColor2D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName({T::Size == 3 ? "Color3" : "Color4", "Flag::UniformBuffers"});
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
} else
#endif
{
setTestCaseTemplateName(T::Size == 3 ? "Color3" : "Color4");
}
Shaders: vertex color support in Phong and Flat.
7 years ago
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: vertex color support in Phong and Flat.
7 years ago
Shaders: port tests away from MeshDataXD.
6 years ago
Trade::MeshData circleData = Primitives::circle2DSolid(32,
Primitives: switch to an enum set for texturable primitives. Making room for GenerateTangents in 3D, and keeping the 2D ones consistent with 3D. Also renamed GenerateTextureCoords to GenerateTextureCoordinates in the remaining places to be consistent with naming in the rest of the APIs.
6 years ago
Primitives::Circle2DFlag::TextureCoordinates);
Shaders: vertex color support in Phong and Flat.
7 years ago
/* Highlight a quarter */
Adapt to Corrade changes.
5 years ago
Containers::Array<T> colorData{DirectInit, circleData.vertexCount(), 0x999999_rgbf};
Shaders: vertex color support in Phong and Flat.
7 years ago
for(std::size_t i = 8; i != 16; ++i)
colorData[i + 1] = 0xffff99_rgbf*1.5f;
GL::Buffer colors;
colors.setData(colorData);
GL::Mesh circle = MeshTools::compile(circleData);
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
circle.addVertexBuffer(colors, 0, GL::Attribute<Shaders::FlatGL2D::Color3::Location, T>{});
Shaders: vertex color support in Phong and Flat.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
GL::Texture2D texture;
Containers::Optional<Trade::ImageData2D> image;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/diffuse-texture.tga")) && (image = importer->image2D(0)));
Shaders: vertex color support in Phong and Flat.
7 years ago
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
Shaders: add UBO support to all shaders.
5 years ago
FlatGL2D shader{FlatGL2D::Flag::Textured|FlatGL2D::Flag::VertexColor|flag};
shader.bindTexture(texture);
if(flag == FlatGL2D::Flag{}) {
shader.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
.setColor(0x9999ff_rgbf)
.draw(circle);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
Shaders: add UBO support to all shaders.
5 years ago
.setColor(0x9999ff_rgbf)
}};
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(circle);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: vertex color support in Phong and Flat.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
/* SwiftShader has minor rounding errors. ARM Mali / Apple A8 a bit more */
const Float maxThreshold = 3.334f, meanThreshold = 0.064f;
Shaders: vertex color support in Phong and Flat.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's worse */
Shaders: adjust thresholds for Flat/Phong vertex color WebGL 1 tests.
7 years ago
const Float maxThreshold = 15.334f, meanThreshold = 4.355f;
Shaders: vertex color support in Phong and Flat.
7 years ago
#endif
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/vertexColor2D.tga"),
Shaders: vertex color support in Phong and Flat.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
}
Shaders: add UBO support to all shaders.
5 years ago
template<class T, FlatGL2D::Flag flag> void FlatGLTest::renderVertexColor3D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL3D::Flag::UniformBuffers) {
setTestCaseTemplateName({T::Size == 3 ? "Color3" : "Color4", "Flag::UniformBuffers"});
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
} else
#endif
{
setTestCaseTemplateName(T::Size == 3 ? "Color3" : "Color4");
}
Shaders: vertex color support in Phong and Flat.
7 years ago
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: vertex color support in Phong and Flat.
7 years ago
Shaders: port tests away from MeshDataXD.
6 years ago
Trade::MeshData sphereData = Primitives::uvSphereSolid(16, 32,
Primitives: switch to an enum set for texturable primitives. Making room for GenerateTangents in 3D, and keeping the 2D ones consistent with 3D. Also renamed GenerateTextureCoords to GenerateTextureCoordinates in the remaining places to be consistent with naming in the rest of the APIs.
6 years ago
Primitives::UVSphereFlag::TextureCoordinates);
Shaders: vertex color support in Phong and Flat.
7 years ago
/* Highlight the middle rings */
Adapt to Corrade changes.
5 years ago
Containers::Array<T> colorData{DirectInit, sphereData.vertexCount(), 0x999999_rgbf};
Shaders: vertex color support in Phong and Flat.
7 years ago
for(std::size_t i = 6*33; i != 9*33; ++i)
colorData[i + 1] = 0xffff99_rgbf*1.5f;
GL::Buffer colors;
colors.setData(colorData);
GL::Mesh sphere = MeshTools::compile(sphereData);
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
sphere.addVertexBuffer(colors, 0, GL::Attribute<Shaders::FlatGL3D::Color4::Location, T>{});
Shaders: vertex color support in Phong and Flat.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
GL::Texture2D texture;
Containers::Optional<Trade::ImageData2D> image;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/diffuse-texture.tga")) && (image = importer->image2D(0)));
Shaders: vertex color support in Phong and Flat.
7 years ago
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
Shaders: add UBO support to all shaders.
5 years ago
FlatGL3D shader{FlatGL3D::Flag::Textured|FlatGL3D::Flag::VertexColor|flag};
shader.bindTexture(texture);
if(flag == FlatGL2D::Flag{}) {
shader.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf))
.setColor(0x9999ff_rgbf)
.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
Shaders: add UBO support to all shaders.
5 years ago
.setColor(0x9999ff_rgbf)
}};
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: vertex color support in Phong and Flat.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
/* SwiftShader has some minor differences on the edges, Apple A8 more */
const Float maxThreshold = 76.67f, meanThreshold = 0.138f;
Shaders: vertex color support in Phong and Flat.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's worse */
Shaders: adjust thresholds for Flat/Phong vertex color WebGL 1 tests.
7 years ago
const Float maxThreshold = 76.67f, meanThreshold = 3.908f;
Shaders: vertex color support in Phong and Flat.
7 years ago
#endif
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/vertexColor3D.tga"),
Shaders: vertex color support in Phong and Flat.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
}
Shaders: rendering tests for Flat shader.
7 years ago
void FlatGLTest::renderAlphaSetup() {
renderSetup();
if(RenderAlphaData[testCaseInstanceId()].blending)
GL::Renderer::enable(GL::Renderer::Feature::Blending);
GL::Renderer::setBlendFunction(GL::Renderer::BlendFunction::SourceAlpha, GL::Renderer::BlendFunction::OneMinusSourceAlpha);
GL::Renderer::setBlendEquation(GL::Renderer::BlendEquation::Add);
}
void FlatGLTest::renderAlphaTeardown() {
if(RenderAlphaData[testCaseInstanceId()].blending)
GL::Renderer::disable(GL::Renderer::Feature::Blending);
renderTeardown();
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag> void FlatGLTest::renderAlpha2D() {
Shaders: rendering tests for Flat shader.
7 years ago
auto&& data = RenderAlphaData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
Containers::Optional<Trade::ImageData2D> image;
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
GL::Texture2D texture;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join({_testDir, "TestFiles", "diffuse-alpha-texture.tga"})) && (image = importer->image2D(0)));
Shaders: rendering tests for Flat shader.
7 years ago
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGBA, image->size())
.setSubImage(0, {}, *image);
MAGNUM_VERIFY_NO_GL_ERROR();
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32,
Primitives: switch to an enum set for texturable primitives. Making room for GenerateTangents in 3D, and keeping the 2D ones consistent with 3D. Also renamed GenerateTextureCoords to GenerateTextureCoordinates in the remaining places to be consistent with naming in the rest of the APIs.
6 years ago
Primitives::Circle2DFlag::TextureCoordinates));
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
FlatGL2D shader{data.flags|flag};
shader.bindTexture(texture);
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
if(flag == FlatGL2D::Flag{}) {
/* Test that the default is correct by not setting the threshold if
it's equal to the default */
if(data.flags & FlatGL2D::Flag::AlphaMask && data.threshold != 0.5f)
shader.setAlphaMask(data.threshold);
shader.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
.setColor(0x9999ff_rgbf)
.draw(circle);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
Shaders: add UBO support to all shaders.
5 years ago
.setColor(0x9999ff_rgbf)
.setAlphaMask(data.threshold)
}};
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(circle);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* Minor differences between opaque and diffuse, not sure why */
const Float maxThreshold = 24.34f, meanThreshold = 0.305f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 31.34f, meanThreshold = 3.945f;
#endif
Shaders: rendering tests for Flat shader.
7 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, data.expected2D),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL3D::Flag flag> void FlatGLTest::renderAlpha3D() {
Shaders: rendering tests for Flat shader.
7 years ago
auto&& data = RenderAlphaData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: rendering tests for Flat shader.
7 years ago
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: rendering tests for Flat shader.
7 years ago
Containers::Optional<Trade::ImageData2D> image;
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
GL::Texture2D texture;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join({_testDir, "TestFiles", "diffuse-alpha-texture.tga"})) && (image = importer->image2D(0)));
Shaders: rendering tests for Flat shader.
7 years ago
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGBA, image->size())
.setSubImage(0, {}, *image);
MAGNUM_VERIFY_NO_GL_ERROR();
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
Primitives: switch to an enum set for texturable primitives. Making room for GenerateTangents in 3D, and keeping the 2D ones consistent with 3D. Also renamed GenerateTextureCoords to GenerateTextureCoordinates in the remaining places to be consistent with naming in the rest of the APIs.
6 years ago
Primitives::UVSphereFlag::TextureCoordinates));
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
FlatGL3D shader{data.flags|flag};
shader.bindTexture(texture);
Shaders: rendering tests for Flat shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
if(flag == FlatGL2D::Flag{}) {
shader.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf))
.setColor(0x9999ff_rgbf);
/* Test that the default is correct by not setting the threshold if
it's equal to the default */
if(data.flags & FlatGL3D::Flag::AlphaMask && data.threshold != 0.5f)
shader.setAlphaMask(data.threshold);
/* For proper Z order draw back faces first and then front faces */
GL::Renderer::setFaceCullingMode(GL::Renderer::PolygonFacing::Front);
shader.draw(sphere);
GL::Renderer::setFaceCullingMode(GL::Renderer::PolygonFacing::Back);
shader.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL3D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
Shaders: add UBO support to all shaders.
5 years ago
.setColor(0x9999ff_rgbf)
.setAlphaMask(data.threshold)
}};
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform);
Shaders: add UBO support to all shaders.
5 years ago
/* For proper Z order draw back faces first and then front faces */
GL::Renderer::setFaceCullingMode(GL::Renderer::PolygonFacing::Front);
shader.draw(sphere);
GL::Renderer::setFaceCullingMode(GL::Renderer::PolygonFacing::Back);
shader.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Flat shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* Minor differences between opaque and diffuse, not sure why. SwiftShader
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
has 5 different pixels on the edges, llvmpipe some off-by-one errors */
const Float maxThreshold = 139.0f, meanThreshold = 0.421f;
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 139.0f, meanThreshold = 4.587f;
#endif
Shaders: rendering tests for Flat shader.
7 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join({_testDir, data.expected3D}),
Shaders: inflate fuzzy thresholds for FlatGLTest. Tested on SwiftShader, WebGL 1 and 2.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Flat shader.
7 years ago
}
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
void FlatGLTest::renderObjectIdSetup() {
GL::Renderer::enable(GL::Renderer::Feature::FaceCulling);
_color = GL::Renderbuffer{};
_color.setStorage(GL::RenderbufferFormat::RGBA8, RenderSize);
_framebuffer = GL::Framebuffer{{{}, RenderSize}};
Test: most tests now pass on Zink as well. Just adding a bunch of extension checks that I thought I would never need again.
6 years ago
_framebuffer.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, _color)
Shaders: support object ID output in Flat and Phong.
7 years ago
/* 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)
.bind();
Test: most tests now pass on Zink as well. Just adding a bunch of extension checks that I thought I would never need again.
6 years ago
/* 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({
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
{FlatGL2D::ColorOutput, GL::Framebuffer::ColorAttachment{0}},
{FlatGL2D::ObjectIdOutput, GL::Framebuffer::ColorAttachment{1}}
Test: most tests now pass on Zink as well. Just adding a bunch of extension checks that I thought I would never need again.
6 years ago
})
.clearColor(1, Vector4ui{27});
}
Shaders: support object ID output in Flat and Phong.
7 years ago
}
void FlatGLTest::renderObjectIdTeardown() {
_color = GL::Renderbuffer{NoCreate};
_objectId = GL::Renderbuffer{NoCreate};
_framebuffer = GL::Framebuffer{NoCreate};
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag> void FlatGLTest::renderObjectId2D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Test: most tests now pass on Zink as well. Just adding a bunch of extension checks that I thought I would never need again.
6 years ago
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
Test: most tests now pass on Zink as well. Just adding a bunch of extension checks that I thought I would never need again.
6 years ago
#endif
Shaders: support object ID output in Flat and Phong.
7 years ago
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32));
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
FlatGL2D shader{FlatGL2D::Flag::ObjectId|flag};
Shaders: add UBO support to all shaders.
5 years ago
if(flag == FlatGL2D::Flag{}) {
shader.setColor(0x9999ff_rgbf)
.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
.setObjectId(48526)
Shaders: add UBO support to all shaders.
5 years ago
.draw(circle);
} else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(Matrix3::projection({2.1f, 2.1f}))
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
.setObjectId(48526)
Shaders: add UBO support to all shaders.
5 years ago
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
.setColor(0x9999ff_rgbf)
}};
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(circle);
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: support object ID output in Flat and Phong.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: support object ID output in Flat and Phong.
7 years ago
/* Color output should have no difference -- same as in colored2D() */
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
const Float maxThreshold = 0.0f, meanThreshold = 0.0f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 11.34f, meanThreshold = 0.51f;
#endif
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/colored2D.tga"),
Shaders: support object ID output in Flat and Phong.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
/* 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>()[10][10], 27);
Shaders: ability to render instanced object ID in Flat/Phong.
6 years ago
/* Inside of the object */
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
CORRADE_COMPARE(image.pixels<UnsignedInt>()[40][46], 48526);
Shaders: support object ID output in Flat and Phong.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL3D::Flag flag> void FlatGLTest::renderObjectId3D() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL3D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Test: most tests now pass on Zink as well. Just adding a bunch of extension checks that I thought I would never need again.
6 years ago
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(GL::Extensions::EXT::gpu_shader4::string() << "is not supported.");
Test: most tests now pass on Zink as well. Just adding a bunch of extension checks that I thought I would never need again.
6 years ago
#endif
Shaders: support object ID output in Flat and Phong.
7 years ago
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Draw), GL::Framebuffer::Status::Complete);
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
FlatGL3D shader{FlatGL3D::Flag::ObjectId|flag};
Shaders: add UBO support to all shaders.
5 years ago
if(flag == FlatGL3D::Flag{}) {
shader.setColor(0x9999ff_rgbf)
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf))
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
.setObjectId(48526)
Shaders: add UBO support to all shaders.
5 years ago
.draw(sphere);
} else if(flag == FlatGL3D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
.setObjectId(48526)
Shaders: add UBO support to all shaders.
5 years ago
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
.setColor(0x9999ff_rgbf)
}};
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(sphere);
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: support object ID output in Flat and Phong.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
Test: fix wrong plugin name in a message.
6 years ago
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Shaders: support object ID output in Flat and Phong.
7 years ago
/* Color output should have no difference -- same as in colored3D() */
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has 5 different pixels on the edges */
const Float maxThreshold = 170.0f, meanThreshold = 0.133f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 170.0f, meanThreshold = 0.456f;
#endif
_framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{0});
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete);
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/colored3D.tga"),
Shaders: support object ID output in Flat and Phong.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
/* 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>()[10][10], 27);
Shaders: ability to render instanced object ID in Flat/Phong.
6 years ago
/* Inside of the object */
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
CORRADE_COMPARE(image.pixels<UnsignedInt>()[40][46], 48526);
Shaders: support object ID output in Flat and Phong.
7 years ago
}
#endif
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL2D::Flag flag> void FlatGLTest::renderInstanced2D() {
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
auto&& data = RenderInstancedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: implement instancing in Flat.
6 years ago
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(GL::Extensions::ARB::instanced_arrays::string() << "is not supported.");
Shaders: implement instancing in Flat.
6 years ago
#elif defined(MAGNUM_TARGET_GLES2)
#ifndef MAGNUM_TARGET_WEBGL
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>() &&
!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::instanced_arrays>() &&
!GL::Context::current().isExtensionSupported<GL::Extensions::NV::instanced_arrays>())
CORRADE_SKIP("GL_{ANGLE,EXT,NV}_instanced_arrays is not supported");
#else
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(GL::Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
Shaders: implement instancing in Flat.
6 years ago
#endif
#endif
GL::Mesh circle = MeshTools::compile(Primitives::circle2DSolid(32,
Primitives::Circle2DFlag::TextureCoordinates));
/* Three circles, each in a different location */
struct {
Matrix3 transformation;
Color3 color;
Vector2 textureOffset;
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
UnsignedInt objectId;
Shaders: implement instancing in Flat.
6 years ago
} instanceData[] {
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
{Matrix3::translation({-1.25f, -1.25f}),
data.flags & FlatGL2D::Flag::Textured ? 0xffffff_rgbf : 0xffff00_rgbf,
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
{0.0f, 0.0f}, 211},
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
{Matrix3::translation({ 1.25f, -1.25f}),
data.flags & FlatGL2D::Flag::Textured ? 0xffffff_rgbf : 0x00ffff_rgbf,
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
{1.0f, 0.0f}, 4627},
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
{Matrix3::translation({ 0.00f, 1.25f}),
data.flags & FlatGL2D::Flag::Textured ? 0xffffff_rgbf : 0xff00ff_rgbf,
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
{0.5f, 1.0f}, 35363},
Shaders: implement instancing in Flat.
6 years ago
};
circle
.addVertexBufferInstanced(GL::Buffer{instanceData}, 1, 0,
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL2D::TransformationMatrix{},
FlatGL2D::Color3{},
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
FlatGL2D::TextureOffset{},
#ifndef MAGNUM_TARGET_GLES2
FlatGL2D::ObjectId{}
#else
4
#endif
)
Shaders: implement instancing in Flat.
6 years ago
.setInstanceCount(3);
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
/* Enable also Object ID, if supported */
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
FlatGL2D::Flags flags = FlatGL2D::Flag::VertexColor|
FlatGL2D::Flag::InstancedTransformation|data.flags|flag;
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
flags |= FlatGL2D::Flag::InstancedObjectId;
}
#endif
FlatGL2D shader{flags};
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
GL::Texture2D texture;
if(data.flags & FlatGL3D::Flag::Textured) {
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
Containers::Optional<Trade::ImageData2D> image;
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/diffuse-texture.tga")) && (image = importer->image2D(0)));
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
shader.bindTexture(texture);
}
Shaders: add UBO support to all shaders.
5 years ago
if(flag == FlatGL2D::Flag{}) {
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
shader
.setColor(data.flags & FlatGL2D::Flag::Textured ? 0xffffff_rgbf : 0xffff00_rgbf)
Shaders: add UBO support to all shaders.
5 years ago
.setTransformationProjectionMatrix(
Matrix3::projection({2.1f, 2.1f})*
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
Matrix3::scaling(Vector2{0.4f}));
if(data.flags & FlatGL3D::Flag::Textured)
shader.setTextureMatrix(Matrix3::scaling(Vector2{0.5f}));
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
shader.setObjectId(1000); /* gets added to the per-instance ID */
}
#endif
shader.draw(circle);
Shaders: add UBO support to all shaders.
5 years ago
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(
Matrix3::projection({2.1f, 2.1f})*
Matrix3::scaling(Vector2{0.4f})
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
.setObjectId(1000) /* gets added to the per-instance ID */
Shaders: add UBO support to all shaders.
5 years ago
}};
GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, {
TextureTransformationUniform{}
.setTextureMatrix(Matrix3::scaling(Vector2{0.5f}))
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
.setColor(data.flags & FlatGL2D::Flag::Textured ? 0xffffff_rgbf : 0xffff00_rgbf)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
}};
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
if(data.flags & FlatGL3D::Flag::Textured)
shader.bindTextureTransformationBuffer(textureTransformationUniform);
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(circle);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: implement instancing in Flat.
6 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
/*
Colored case:
- First should be lower left, yellow with a yellow base color, so
yellow
- Second lower right, cyan with a yellow base color, so green
- Third up center, magenta with a yellow base color, so red
Textured case:
- Lower left has bottom left numbers, so light 7881
- Lower light has bottom right, 1223
- Up center has 6778
*/
Shaders: implement instancing in Flat.
6 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
Utility::Directory::join({_testDir, "FlatTestFiles", data.expected2D}),
(DebugTools::CompareImageToFile{_manager, data.maxThreshold, data.meanThreshold}));
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
#ifndef MAGNUM_TARGET_GLES2
/* 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). */
#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();
CORRADE_COMPARE(image.pixels<UnsignedInt>()[5][5], 27); /* Outside */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[24][24], 1211);
CORRADE_COMPARE(image.pixels<UnsignedInt>()[24][56], 5627);
CORRADE_COMPARE(image.pixels<UnsignedInt>()[56][40], 36363);
}
#endif
Shaders: implement instancing in Flat.
6 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<FlatGL3D::Flag flag> void FlatGLTest::renderInstanced3D() {
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
auto&& data = RenderInstancedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == FlatGL2D::Flag::UniformBuffers) {
setTestCaseTemplateName("Flag::UniformBuffers");
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
}
#endif
Shaders: implement instancing in Flat.
6 years ago
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(GL::Extensions::ARB::instanced_arrays::string() << "is not supported.");
Shaders: implement instancing in Flat.
6 years ago
#elif defined(MAGNUM_TARGET_GLES2)
#ifndef MAGNUM_TARGET_WEBGL
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>() &&
!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::instanced_arrays>() &&
!GL::Context::current().isExtensionSupported<GL::Extensions::NV::instanced_arrays>())
CORRADE_SKIP("GL_{ANGLE,EXT,NV}_instanced_arrays is not supported");
#else
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(GL::Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
Shaders: implement instancing in Flat.
6 years ago
#endif
#endif
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
Primitives::UVSphereFlag::TextureCoordinates));
/* Three spheres, each in a different location */
struct {
Matrix4 transformation;
Color3 color;
Vector2 textureOffset;
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
UnsignedInt objectId;
Shaders: implement instancing in Flat.
6 years ago
} instanceData[] {
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
{Matrix4::translation({-1.25f, -1.25f, 0.0f})*
/* To be consistent with Phong's output where it tests that the
normal matrix is applied properly */
Matrix4::rotationX(90.0_degf),
data.flags & FlatGL3D::Flag::Textured ? 0xffffff_rgbf : 0xffff00_rgbf,
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
{0.0f, 0.0f}, 211},
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
{Matrix4::translation({ 1.25f, -1.25f, 0.0f}),
data.flags & FlatGL3D::Flag::Textured ? 0xffffff_rgbf : 0x00ffff_rgbf,
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
{1.0f, 0.0f}, 4627},
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
{Matrix4::translation({ 0.0f, 1.0f, 1.0f}),
data.flags & FlatGL3D::Flag::Textured ? 0xffffff_rgbf : 0xff00ff_rgbf,
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
{0.5f, 1.0f}, 35363}
Shaders: implement instancing in Flat.
6 years ago
};
sphere
.addVertexBufferInstanced(GL::Buffer{instanceData}, 1, 0,
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
FlatGL3D::TransformationMatrix{},
FlatGL3D::Color3{},
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
FlatGL3D::TextureOffset{},
#ifndef MAGNUM_TARGET_GLES2
FlatGL2D::ObjectId{}
#else
4
#endif
)
Shaders: implement instancing in Flat.
6 years ago
.setInstanceCount(3);
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
/* Enable also Object ID, if supported */
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
FlatGL3D::Flags flags = FlatGL3D::Flag::VertexColor|
FlatGL3D::Flag::InstancedTransformation|data.flags|flag;
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
flags |= FlatGL2D::Flag::InstancedObjectId;
}
#endif
FlatGL3D shader{flags};
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
GL::Texture2D texture;
if(data.flags & FlatGL2D::Flag::Textured) {
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
Containers::Optional<Trade::ImageData2D> image;
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/diffuse-texture.tga")) && (image = importer->image2D(0)));
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
shader.bindTexture(texture);
}
Shaders: add UBO support to all shaders.
5 years ago
if(flag == FlatGL3D::Flag{}) {
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
shader
.setColor(data.flags & FlatGL2D::Flag::Textured ? 0xffffff_rgbf : 0xffff00_rgbf)
Shaders: add UBO support to all shaders.
5 years ago
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
Matrix4::scaling(Vector3{0.4f}));
if(data.flags & FlatGL3D::Flag::Textured)
shader.setTextureMatrix(Matrix3::scaling(Vector2{0.5f}));
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
shader.setObjectId(1000); /* gets added to the per-instance ID */
}
#endif
shader.draw(sphere);
Shaders: add UBO support to all shaders.
5 years ago
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == FlatGL2D::Flag::UniformBuffers) {
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, {
TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::scaling(Vector3{0.4f})
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
FlatDrawUniform{}
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
.setObjectId(1000) /* gets added to the per-instance ID */
Shaders: add UBO support to all shaders.
5 years ago
}};
GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, {
TextureTransformationUniform{}
.setTextureMatrix(Matrix3::scaling(Vector2{0.5f}))
}};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
FlatMaterialUniform{}
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
.setColor(data.flags & FlatGL3D::Flag::Textured ? 0xffffff_rgbf : 0xffff00_rgbf)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
}};
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
if(data.flags & FlatGL3D::Flag::Textured)
shader.bindTextureTransformationBuffer(textureTransformationUniform);
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
.bindDrawBuffer(drawUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindMaterialBuffer(materialUniform)
Shaders: add UBO support to all shaders.
5 years ago
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: implement instancing in Flat.
6 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
/*
Colored case:
- First should be lower left, yellow with a yellow base color, so
yellow
- Second lower right, cyan with a yellow base color, so green
- Third up center, magenta with a yellow base color, so red
Textured case:
- Lower left has bottom left numbers, so light 7881, rotated (78
visible)
- Lower light has bottom right, 1223
- Up center has 6778
*/
Shaders: implement instancing in Flat.
6 years ago
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Shaders: separate instanced colored and textured test cases. With everything smashed together it was quite annoying to eyeball and too easy to miss issues.
5 years ago
Utility::Directory::join({_testDir, "FlatTestFiles", data.expected3D}),
(DebugTools::CompareImageToFile{_manager, data.maxThreshold, data.meanThreshold}));
Shaders: test instanced object ID in the instanced test case. Is more self-contained that way (the new multidraw tests were done this way also).
5 years ago
#ifndef MAGNUM_TARGET_GLES2
/* 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). */
#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();
CORRADE_COMPARE(image.pixels<UnsignedInt>()[5][5], 27); /* Outside */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[24][24], 1211);
CORRADE_COMPARE(image.pixels<UnsignedInt>()[24][56], 5627);
CORRADE_COMPARE(image.pixels<UnsignedInt>()[56][40], 36363);
}
#endif
Shaders: implement instancing in Flat.
6 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
void FlatGLTest::renderMulti2D() {
auto&& data = RenderMultiData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
Shaders: multidraw support in all builtin shaders.
5 years ago
if(data.flags >= FlatGL2D::Flag::MultiDraw) {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::shader_draw_parameters>())
CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported.");
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::multi_draw>())
CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported.");
#else
if(!GL::Context::current().isExtensionSupported<GL::Extensions::WEBGL::multi_draw>())
CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported.");
#endif
}
Shaders: add UBO support to all shaders.
5 years ago
GL::Texture2D texture;
if(data.flags & FlatGL2D::Flag::Textured) {
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
Containers::Optional<Trade::ImageData2D> image;
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/diffuse-texture.tga")) && (image = importer->image2D(0)));
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, GL::TextureFormat::RGB8, image->size())
.setSubImage(0, {}, *image);
}
/* Circle is a fan, plane is a strip, make it indexed first */
Trade::MeshData circleData = MeshTools::generateIndices(Primitives::circle2DSolid(32,
Primitives::Circle2DFlag::TextureCoordinates));
Trade::MeshData squareData = MeshTools::generateIndices(Primitives::squareSolid(
Primitives::SquareFlag::TextureCoordinates));
Trade::MeshData triangleData = MeshTools::generateIndices(Primitives::circle2DSolid(3,
Primitives::Circle2DFlag::TextureCoordinates));
GL::Mesh mesh = MeshTools::compile(MeshTools::concatenate({circleData, squareData, triangleData}));
GL::MeshView circle{mesh};
circle.setCount(circleData.indexCount());
GL::MeshView square{mesh};
square.setCount(squareData.indexCount())
.setIndexRange(circleData.indexCount());
GL::MeshView triangle{mesh};
triangle.setCount(triangleData.indexCount())
.setIndexRange(circleData.indexCount() + squareData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.
The data.uniformIncrement is set high enough to ensure that, in the
non-offset-bind case this value is 1. */
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
Containers::Array<FlatMaterialUniform> materialData{data.uniformIncrement + 1};
materialData[0*data.uniformIncrement] = FlatMaterialUniform{}
.setColor(data.flags & FlatGL2D::Flag::Textured ?
0xffffff_rgbf : 0x0000ff_rgbf);
materialData[1*data.uniformIncrement] = FlatMaterialUniform{}
.setColor(data.flags & FlatGL2D::Flag::Textured ?
0xffffff_rgbf : 0xff0000_rgbf);
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
Shaders: add UBO support to all shaders.
5 years ago
Containers::Array<TransformationProjectionUniform2D> transformationProjectionData{2*data.uniformIncrement + 1};
transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(
Matrix3::projection({2.1f, 2.1f})*
Matrix3::scaling(Vector2{0.4f})*
Matrix3::translation({-1.25f, -1.25f})
);
transformationProjectionData[1*data.uniformIncrement] = TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(
Matrix3::projection({2.1f, 2.1f})*
Matrix3::scaling(Vector2{0.4f})*
Matrix3::translation({ 1.25f, -1.25f})
);
transformationProjectionData[2*data.uniformIncrement] = TransformationProjectionUniform2D{}
.setTransformationProjectionMatrix(
Matrix3::projection({2.1f, 2.1f})*
Matrix3::scaling(Vector2{0.4f})*
Matrix3::translation({ 0.00f, 1.25f})
);
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
.setTextureMatrix(
Matrix3::scaling(Vector2{0.5f})*
Matrix3::translation({0.0f, 0.0f})
);
textureTransformationData[1*data.uniformIncrement] = TextureTransformationUniform{}
.setTextureMatrix(
Matrix3::scaling(Vector2{0.5f})*
Matrix3::translation({1.0f, 0.0f})
);
textureTransformationData[2*data.uniformIncrement] = TextureTransformationUniform{}
.setTextureMatrix(
Matrix3::scaling(Vector2{0.5f})*
Matrix3::translation({0.5f, 1.0f})
);
GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
Containers::Array<FlatDrawUniform> drawData{2*data.uniformIncrement + 1};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
/* Material offsets are zero if we have single draw, as those are
done with UBO offset bindings instead. */
Shaders: add UBO support to all shaders.
5 years ago
drawData[0*data.uniformIncrement] = FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.setMaterialId(data.drawCount == 1 ? 0 : 1)
Shaders: add UBO support to all shaders.
5 years ago
.setObjectId(1211);
drawData[1*data.uniformIncrement] = FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.setMaterialId(data.drawCount == 1 ? 0 : 0)
Shaders: add UBO support to all shaders.
5 years ago
.setObjectId(5627);
drawData[2*data.uniformIncrement] = FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.setMaterialId(data.drawCount == 1 ? 0 : 1)
Shaders: add UBO support to all shaders.
5 years ago
.setObjectId(36363);
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
FlatGL2D shader{FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::ObjectId|data.flags, data.materialCount, data.drawCount};
Shaders: add UBO support to all shaders.
5 years ago
if(data.flags & FlatGL2D::Flag::Textured)
shader.bindTexture(texture);
/* Just one draw, rebinding UBOs each time */
if(data.drawCount == 1) {
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
shader.bindMaterialBuffer(materialUniform,
1*data.uniformIncrement*sizeof(FlatMaterialUniform),
sizeof(FlatMaterialUniform));
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform,
0*data.uniformIncrement*sizeof(TransformationProjectionUniform2D),
sizeof(TransformationProjectionUniform2D));
shader.bindDrawBuffer(drawUniform,
0*data.uniformIncrement*sizeof(FlatDrawUniform),
sizeof(FlatDrawUniform));
if(data.flags & FlatGL2D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform,
0*data.uniformIncrement*sizeof(TextureTransformationUniform),
sizeof(TextureTransformationUniform));
shader.draw(circle);
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
shader.bindMaterialBuffer(materialUniform,
0*data.uniformIncrement*sizeof(FlatMaterialUniform),
sizeof(FlatMaterialUniform));
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform,
1*data.uniformIncrement*sizeof(TransformationProjectionUniform2D),
sizeof(TransformationProjectionUniform2D));
shader.bindDrawBuffer(drawUniform,
1*data.uniformIncrement*sizeof(FlatDrawUniform),
sizeof(FlatDrawUniform));
if(data.flags & FlatGL2D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform,
1*data.uniformIncrement*sizeof(TextureTransformationUniform),
sizeof(TextureTransformationUniform));
shader.draw(square);
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
shader.bindMaterialBuffer(materialUniform,
1*data.uniformIncrement*sizeof(FlatMaterialUniform),
sizeof(FlatMaterialUniform));
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform,
2*data.uniformIncrement*sizeof(TransformationProjectionUniform2D),
sizeof(TransformationProjectionUniform2D));
shader.bindDrawBuffer(drawUniform,
2*data.uniformIncrement*sizeof(FlatDrawUniform),
sizeof(FlatDrawUniform));
if(data.flags & FlatGL2D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform,
2*data.uniformIncrement*sizeof(TextureTransformationUniform),
sizeof(TextureTransformationUniform));
shader.draw(triangle);
Shaders: multidraw support in all builtin shaders.
5 years ago
/* Otherwise using the draw offset / multidraw */
Shaders: add UBO support to all shaders.
5 years ago
} else {
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform);
Shaders: add UBO support to all shaders.
5 years ago
if(data.flags & FlatGL2D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform);
Shaders: multidraw support in all builtin shaders.
5 years ago
if(data.flags >= FlatGL2D::Flag::MultiDraw)
shader.draw({circle, square, triangle});
else {
shader.setDrawOffset(0)
.draw(circle);
shader.setDrawOffset(1)
.draw(square);
shader.setDrawOffset(2)
.draw(triangle);
}
Shaders: add UBO support to all shaders.
5 years ago
}
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
/*
Colored case:
- Circle should be lower left, red
- Square lower right, blue
- Triangle up center, red
Textured case:
- Circle should have bottom left numbers, so light 7881
- Square bottom right, 1223
- Triangle 6778
*/
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Utility::Directory::join({_testDir, "FlatTestFiles", data.expected2D}),
(DebugTools::CompareImageToFile{_manager, data.maxThreshold, data.meanThreshold}));
/* 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). */
#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();
CORRADE_COMPARE(image.pixels<UnsignedInt>()[5][5], 27); /* Outside */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[24][24], 1211); /* Circle */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[24][56], 5627); /* Square */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[56][40], 36363); /* Triangle */
}
}
void FlatGLTest::renderMulti3D() {
auto&& data = RenderMultiData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>())
CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported.");
#endif
Shaders: multidraw support in all builtin shaders.
5 years ago
if(data.flags >= FlatGL3D::Flag::MultiDraw) {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::shader_draw_parameters>())
CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported.");
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::multi_draw>())
CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported.");
#else
if(!GL::Context::current().isExtensionSupported<GL::Extensions::WEBGL::multi_draw>())
CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported.");
#endif
}
Shaders: add UBO support to all shaders.
5 years ago
GL::Texture2D texture;
if(data.flags & FlatGL3D::Flag::Textured) {
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
Containers::Optional<Trade::ImageData2D> image;
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/diffuse-texture.tga")) && (image = importer->image2D(0)));
texture.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, GL::TextureFormat::RGB8, image->size())
.setSubImage(0, {}, *image);
}
Trade::MeshData sphereData = Primitives::uvSphereSolid(16, 32,
Primitives::UVSphereFlag::TextureCoordinates);
/* Plane is a strip, make it indexed first */
Trade::MeshData planeData = MeshTools::generateIndices(Primitives::planeSolid(
Primitives::PlaneFlag::TextureCoordinates));
Trade::MeshData coneData = Primitives::coneSolid(1, 32, 1.0f,
Primitives::ConeFlag::TextureCoordinates);
GL::Mesh mesh = MeshTools::compile(MeshTools::concatenate({sphereData, planeData, coneData}));
GL::MeshView sphere{mesh};
sphere.setCount(sphereData.indexCount());
GL::MeshView plane{mesh};
plane.setCount(planeData.indexCount())
.setIndexRange(sphereData.indexCount());
GL::MeshView cone{mesh};
cone.setCount(coneData.indexCount())
.setIndexRange(sphereData.indexCount() + planeData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.
The data.uniformIncrement is set high enough to ensure that, in the
non-offset-bind case this value is 1. */
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
Containers::Array<FlatMaterialUniform> materialData{data.uniformIncrement + 1};
materialData[0*data.uniformIncrement] = FlatMaterialUniform{}
.setColor(data.flags & FlatGL2D::Flag::Textured ?
0xffffff_rgbf : 0x0000ff_rgbf);
materialData[1*data.uniformIncrement] = FlatMaterialUniform{}
.setColor(data.flags & FlatGL2D::Flag::Textured ?
0xffffff_rgbf : 0xff0000_rgbf);
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
Shaders: add UBO support to all shaders.
5 years ago
Containers::Array<TransformationProjectionUniform3D> transformationProjectionData{2*data.uniformIncrement + 1};
transformationProjectionData[0*data.uniformIncrement] = TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::scaling(Vector3{0.4f})*
Matrix4::translation({-1.25f, -1.25f, 0.0f})*
/* To be consistent with Phong's output where it tests that the
normal matrix is applied properly */
Matrix4::rotationX(90.0_degf)
);
transformationProjectionData[1*data.uniformIncrement] = TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::scaling(Vector3{0.4f})*
Matrix4::translation({ 1.25f, -1.25f, 0.0f})
);
transformationProjectionData[2*data.uniformIncrement] = TransformationProjectionUniform3D{}
.setTransformationProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)*
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::scaling(Vector3{0.4f})*
Matrix4::translation({ 0.0f, 1.0f, 1.0f})
);
GL::Buffer transformationProjectionUniform{GL::Buffer::TargetHint::Uniform, transformationProjectionData};
Containers::Array<TextureTransformationUniform> textureTransformationData{2*data.uniformIncrement + 1};
textureTransformationData[0*data.uniformIncrement] = TextureTransformationUniform{}
.setTextureMatrix(
Matrix3::scaling(Vector2{0.5f})*
Matrix3::translation({0.0f, 0.0f})
);
textureTransformationData[1*data.uniformIncrement] = TextureTransformationUniform{}
.setTextureMatrix(
Matrix3::scaling(Vector2{0.5f})*
Matrix3::translation({1.0f, 0.0f})
);
textureTransformationData[2*data.uniformIncrement] = TextureTransformationUniform{}
.setTextureMatrix(
Matrix3::scaling(Vector2{0.5f})*
Matrix3::translation({0.5f, 1.0f})
);
GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, textureTransformationData};
Containers::Array<FlatDrawUniform> drawData{2*data.uniformIncrement + 1};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
/* Material offsets are zero if we have single draw, as those are done with
UBO offset bindings instead. */
Shaders: add UBO support to all shaders.
5 years ago
drawData[0*data.uniformIncrement] = FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.setMaterialId(data.drawCount == 1 ? 0 : 1)
Shaders: add UBO support to all shaders.
5 years ago
.setObjectId(1211);
drawData[1*data.uniformIncrement] = FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.setMaterialId(data.drawCount == 1 ? 0 : 0)
Shaders: add UBO support to all shaders.
5 years ago
.setObjectId(5627);
drawData[2*data.uniformIncrement] = FlatDrawUniform{}
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.setMaterialId(data.drawCount == 1 ? 0 : 1)
Shaders: add UBO support to all shaders.
5 years ago
.setObjectId(36363);
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
FlatGL3D shader{FlatGL3D::Flag::UniformBuffers|FlatGL3D::Flag::ObjectId|data.flags, data.materialCount, data.drawCount};
Shaders: add UBO support to all shaders.
5 years ago
if(data.flags & FlatGL3D::Flag::Textured)
shader.bindTexture(texture);
/* Just one draw, rebinding UBOs each time */
if(data.drawCount == 1) {
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
shader.bindMaterialBuffer(materialUniform,
1*data.uniformIncrement*sizeof(FlatMaterialUniform),
sizeof(FlatMaterialUniform));
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform,
0*data.uniformIncrement*sizeof(TransformationProjectionUniform3D),
sizeof(TransformationProjectionUniform3D));
shader.bindDrawBuffer(drawUniform,
0*data.uniformIncrement*sizeof(FlatDrawUniform),
sizeof(FlatDrawUniform));
if(data.flags & FlatGL3D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform,
0*data.uniformIncrement*sizeof(TextureTransformationUniform),
sizeof(TextureTransformationUniform));
shader.draw(sphere);
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
shader.bindMaterialBuffer(materialUniform,
0*data.uniformIncrement*sizeof(FlatMaterialUniform),
sizeof(FlatMaterialUniform));
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform,
1*data.uniformIncrement*sizeof(TransformationProjectionUniform3D),
sizeof(TransformationProjectionUniform3D));
shader.bindDrawBuffer(drawUniform,
1*data.uniformIncrement*sizeof(FlatDrawUniform),
sizeof(FlatDrawUniform));
if(data.flags & FlatGL3D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform,
1*data.uniformIncrement*sizeof(TextureTransformationUniform),
sizeof(TextureTransformationUniform));
shader.draw(plane);
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
shader.bindMaterialBuffer(materialUniform,
1*data.uniformIncrement*sizeof(FlatMaterialUniform),
sizeof(FlatMaterialUniform));
Shaders: add UBO support to all shaders.
5 years ago
shader.bindTransformationProjectionBuffer(transformationProjectionUniform,
2*data.uniformIncrement*sizeof(TransformationProjectionUniform3D),
sizeof(TransformationProjectionUniform3D));
shader.bindDrawBuffer(drawUniform,
2*data.uniformIncrement*sizeof(FlatDrawUniform),
sizeof(FlatDrawUniform));
if(data.flags & FlatGL3D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform,
2*data.uniformIncrement*sizeof(TextureTransformationUniform),
sizeof(TextureTransformationUniform));
shader.draw(cone);
Shaders: multidraw support in all builtin shaders.
5 years ago
/* Otherwise using the draw offset / multidraw */
Shaders: add UBO support to all shaders.
5 years ago
} else {
shader.bindTransformationProjectionBuffer(transformationProjectionUniform)
Shaders: supply Flat material information in a separate UBO as well. While it's one additional indirection (that has an extra cost on Intel GPUs apparently, like with Phong and MeshVisualizer and DistanceFieldVector already), with the assumption that draws usually share the material info it allows to cram more draws into the 16/64k UBO limit as the per-draw data are now one vec4 smaller. For the indirection overhead I can imagine adding a new flag which makes material mapping implicit (materialId == drawId). That seems to put the benchmark numbers back to the original speed. Same could be done for other shaders.
5 years ago
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform);
Shaders: add UBO support to all shaders.
5 years ago
if(data.flags & FlatGL3D::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform);
Shaders: multidraw support in all builtin shaders.
5 years ago
if(data.flags >= FlatGL3D::Flag::MultiDraw)
shader.draw({sphere, plane, cone});
else {
shader.setDrawOffset(0)
.draw(sphere);
shader.setDrawOffset(1)
.draw(plane);
shader.setDrawOffset(2)
.draw(cone);
}
Shaders: add UBO support to all shaders.
5 years ago
}
MAGNUM_VERIFY_NO_GL_ERROR();
if(!(_manager.loadState("AnyImageImporter") & PluginManager::LoadState::Loaded) ||
!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter / TgaImporter plugins not found.");
/*
Colored case:
- Sphere should be lower left, red
- Plane lower right, blue
- Cone up center, red
Textured case:
- Sphere should have bottom left numbers, so light 7881, rotated (78
visible)
- Plane bottom right, 1223
- Cone 6778
*/
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(_framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm}).pixels<Color4ub>()),
Utility::Directory::join({_testDir, "FlatTestFiles", data.expected3D}),
(DebugTools::CompareImageToFile{_manager, data.maxThreshold, data.meanThreshold}));
/* 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). */
#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();
CORRADE_COMPARE(image.pixels<UnsignedInt>()[5][5], 27); /* Outside */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[24][24], 1211); /* Sphere */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[24][56], 5627); /* Plane */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[56][40], 36363); /* Circle */
}
}
#endif
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
}}}}
Shaders: test compilation of Flat and VertexColor shaders.
13 years ago
Made Test/AbstractOpenGLTester.h a public and documented API. There will be numerous additions to this one so it made sense to make it a static library instead of a header-only library. That also allows CMake users to just link to Magnum::OpenGLTester instead of going through the pain of a huge branching in order to find a correct windowless application just to run their tests. It could have been done even without the static library using a INTERFACE target, but that wouldn't work on CMake < 3.0 (which, unfortunately, quite a few people are still stuck with). Unfortunately it's already heavily used elsewhere so I had to go through the pain of deprecating the old implementation. The old implementation was header-only so it can't be just typedef'd to the new one as there would be linker failures. So the old header is just kept as it was, with only the macros reduced.
9 years ago
CORRADE_TEST_MAIN(Magnum::Shaders::Test::FlatGLTest)