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.
8909 Commits
21 Branches
19 Tags
70 MiB
Tree: 4c4f63b5a0
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4c4f63b5a0'
${ noResults }
magnum/src/Magnum/Shaders/Test/PhongGLTest.cpp

3312 lines
143 KiB
Raw Normal View History Unescape

Shaders: test compilation of Phong shader. Currently fails for some combinations.
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 Phong shader. Currently fails for some combinations.
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 on Phong::bindTexture*() if no texture was enabled.
8 years ago
#include <sstream>
Shaders: rendering tests for Phong shader.
7 years ago
#include <Corrade/Containers/Optional.h>
#include <Corrade/Containers/StridedArrayView.h>
GL: rework Context to not use any STL containers. We're going to eventually include this class in all Application classes (need that in order to inherit a to-be-created Configuration class) and the <string> and <vector> would be just too much. This change caused magnum-gl-info.wasm (WebGL 2 build) to go down from 247 to 245 kB. Not much, but that's I guess because there's still a lot other vectors of strings elsewhere. There's a lot more places to clean up, will do those in separate commits. This change is the most atomic I could do, and it introduces a breaking change to all APIs that returned a std::vector or a std::string. Fortunately (or as I hope) those weren't used that much, so it shouldn't cause build breakages for that many people. Quite a lot of the optimization ideas is borrowed from the new Vk library -- such as "interning" the driver workaround strings to avoid allocating their copies.
5 years ago
#include <Corrade/Containers/StringView.h>
Shaders: rendering tests for Phong shader.
7 years ago
#include <Corrade/PluginManager/Manager.h>
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
#include <Corrade/TestSuite/Compare/Numeric.h>
Adapted to Corrade changes. Mostly missing includes now.
7 years ago
#include <Corrade/Utility/DebugStl.h>
Shaders: rendering tests for Phong shader.
7 years ago
#include <Corrade/Utility/Directory.h>
Shaders: ensure the ObjectId and Bitangent attribs are not used together. These deliberately share the same binding (because there's very little space), but the shader wasn't guarding that. Discovered completely by accident when adding tests for "multidraw with all the things" -- Mesa gives just a warning, but ANGLE straight out fails the shader compilation, so better have an assert there.
5 years ago
#include <Corrade/Utility/FormatStl.h>
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 years ago
Shaders: rendering tests for Phong shader.
7 years ago
#include "Magnum/Image.h"
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 years ago
#include "Magnum/ImageView.h"
Shaders: rendering tests for Phong shader.
7 years ago
#include "Magnum/PixelFormat.h"
#include "Magnum/DebugTools/CompareImage.h"
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#include "Magnum/GL/Context.h"
Shaders: implement instancing in Phong.
6 years ago
#include "Magnum/GL/Extensions.h"
Shaders: rendering tests for Phong shader.
7 years ago
#include "Magnum/GL/Framebuffer.h"
#include "Magnum/GL/Mesh.h"
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
#include "Magnum/GL/OpenGLTester.h"
Shaders: rendering tests for Phong shader.
7 years ago
#include "Magnum/GL/Renderer.h"
#include "Magnum/GL/Renderbuffer.h"
#include "Magnum/GL/RenderbufferFormat.h"
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 years ago
#include "Magnum/GL/Texture.h"
#include "Magnum/GL/TextureFormat.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/Matrix4.h"
Shaders: rendering tests for Phong shader.
7 years ago
#include "Magnum/MeshTools/Compile.h"
#include "Magnum/MeshTools/Transform.h"
#include "Magnum/Primitives/Plane.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/PhongGL.h"
Shaders: rendering tests for Phong 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 Phong 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/Shaders/Generic.h"
#include "Magnum/Shaders/Phong.h"
#endif
Shaders: rendering tests for Phong shader.
7 years ago
#include "configure.h"
Shaders: test compilation of Phong shader. Currently fails for some combinations.
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 Phong shader. Currently fails for some combinations.
13 years ago
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
struct PhongGLTest: GL::OpenGLTester {
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
explicit PhongGLTest();
Shaders: test compilation of Phong shader. Currently fails for some combinations.
13 years ago
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
void construct();
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
void constructUniformBuffers();
#endif
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
void constructMove();
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
void constructMoveUniformBuffers();
#endif
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 years ago
Shaders: ensure the ObjectId and Bitangent attribs are not used together. These deliberately share the same binding (because there's very little space), but the shader wasn't guarding that. Discovered completely by accident when adding tests for "multidraw with all the things" -- Mesa gives just a warning, but ANGLE straight out fails the shader compilation, so better have an assert there.
5 years ago
void constructInvalid();
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
void constructUniformBuffersInvalid();
#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
void setUniformUniformBuffersEnabled();
void bindBufferUniformBuffersNotEnabled();
#endif
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 years ago
void bindTexturesNotEnabled();
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
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
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
void bindTextureTransformBufferNotEnabled();
#endif
#ifndef MAGNUM_TARGET_GLES2
Shaders: support object ID output in Flat and Phong.
7 years ago
void setObjectIdNotEnabled();
#endif
Shaders: support multiple lights in Phong.
8 years ago
void setWrongLightCount();
void setWrongLightId();
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
void setWrongDrawOffset();
#endif
Shaders: rendering tests for Phong shader.
7 years ago
void renderSetup();
void renderTeardown();
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderDefaults();
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderColored();
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderSinglePixelTextured();
Shaders: rendering tests for Phong shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderTextured();
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderTexturedNormal();
Shaders: rendering tests for Phong shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
template<class T, PhongGL::Flag flag = PhongGL::Flag{}> void renderVertexColor();
Shaders: vertex color support in Phong and Flat.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderShininess();
Shaders: rendering tests for Phong shader.
7 years ago
void renderAlphaSetup();
void renderAlphaTeardown();
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderAlpha();
Shaders: rendering tests for Phong 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<PhongGL::Flag flag = PhongGL::Flag{}> void renderObjectId();
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderLights();
/* This tests something that's irrelevant to UBOs */
Shaders: properly test Phong one-by-one light property setters. Testing that they don't assert *isn't* enough.
6 years ago
void renderLightsSetOneByOne();
Shaders: add UBO support to all shaders.
5 years ago
/* This tests just the algorithm, not affected by UBOs */
Shaders: repro case for a bug in Phong light direction calculation. Interestingly enough / sadly none of the tests showed a clear difference when removing the incorrect normalization, so here's a dedicated test case. Sigh.
6 years ago
void renderLowLightAngle();
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderZeroLights();
template<PhongGL::Flag flag = PhongGL::Flag{}> void renderInstanced();
#ifndef MAGNUM_TARGET_GLES2
void renderMulti();
#endif
Shaders: implement instancing in Phong.
6 years ago
Shaders: rendering tests for Phong 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 Phong shader.
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 Phong shader.
7 years ago
GL::Framebuffer _framebuffer{NoCreate};
Shaders: test compilation of Phong shader. Currently fails for some combinations.
13 years ago
};
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
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
[L] point lights
[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 BADLIOM
ES2 xx
ES3 BADLIOx
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
Mesa AMD BAD I
Mesa llvmpipe BAD I
Shaders: multidraw support in all builtin shaders.
5 years ago
SwiftShader ES2 BADLIxx
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
ES3 BADLI
Shaders: multidraw support in all builtin shaders.
5 years ago
ANGLE ES2 xx
ES3 BADLIOM
ARM Mali (Huawei P10) ES2 BAD xx
ES3 BADLIOx
WebGL (on Mesa Intel) 1.0 BAD xx
2.0 BADLIOM
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: multidraw support in all builtin shaders.
5 years ago
Intel macOS BADLIOx
iPhone 6 w/ iOS 12.4 ES3 BAD x
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
*/
Shaders: simplify the Phong construction test a bit. Ugh.
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
PhongGL::Flags flags;
Shaders: support multiple lights in Phong.
8 years ago
UnsignedInt lightCount;
Shaders: simplify the Phong construction test a bit. Ugh.
8 years ago
} ConstructData[]{
Shaders: support multiple lights in Phong.
8 years ago
{"", {}, 1},
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
{"ambient texture", PhongGL::Flag::AmbientTexture, 1},
{"diffuse texture", PhongGL::Flag::DiffuseTexture, 1},
{"diffuse texture + texture transform", PhongGL::Flag::DiffuseTexture|PhongGL::Flag::TextureTransformation, 1},
{"specular texture", PhongGL::Flag::SpecularTexture, 1},
{"normal texture", PhongGL::Flag::NormalTexture, 1},
{"normal texture + separate bitangents", PhongGL::Flag::NormalTexture|PhongGL::Flag::Bitangent, 1},
{"separate bitangents alone", PhongGL::Flag::Bitangent, 1},
{"ambient + diffuse texture", PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture, 1},
{"ambient + specular texture", PhongGL::Flag::AmbientTexture|PhongGL::Flag::SpecularTexture, 1},
{"diffuse + specular texture", PhongGL::Flag::DiffuseTexture|PhongGL::Flag::SpecularTexture, 1},
{"ambient + diffuse + specular texture", PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::SpecularTexture, 1},
{"ambient + diffuse + specular + normal texture", PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::SpecularTexture|PhongGL::Flag::NormalTexture, 1},
{"alpha mask", PhongGL::Flag::AlphaMask, 1},
{"alpha mask + diffuse texture", PhongGL::Flag::AlphaMask|PhongGL::Flag::DiffuseTexture, 1},
{"vertex colors", PhongGL::Flag::VertexColor, 1},
{"vertex colors + diffuse texture", PhongGL::Flag::VertexColor|PhongGL::Flag::DiffuseTexture, 1},
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", PhongGL::Flag::ObjectId, 1},
{"instanced object ID", PhongGL::Flag::InstancedObjectId, 1},
{"object ID + alpha mask + specular texture", PhongGL::Flag::ObjectId|PhongGL::Flag::AlphaMask|PhongGL::Flag::SpecularTexture, 1},
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
{"five lights", {}, 5},
Shaders: implement instancing in Phong.
6 years ago
{"zero lights", {}, 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
{"instanced transformation", PhongGL::Flag::InstancedTransformation, 3},
{"instanced specular texture offset", PhongGL::Flag::SpecularTexture|PhongGL::Flag::InstancedTextureOffset, 3},
Shaders: ensure the ObjectId and Bitangent attribs are not used together. These deliberately share the same binding (because there's very little space), but the shader wasn't guarding that. Discovered completely by accident when adding tests for "multidraw with all the things" -- Mesa gives just a warning, but ANGLE straight out fails the shader compilation, so better have an assert there.
5 years ago
{"instanced normal texture offset", PhongGL::Flag::NormalTexture|PhongGL::Flag::InstancedTextureOffset, 3},
#ifndef MAGNUM_TARGET_GLES2
/* InstancedObjectId|Bitangent is disallowed (checked in
ConstructInvalidData), but this should work */
{"object ID + normal texture with bitangent from tangent", PhongGL::Flag::InstancedObjectId|PhongGL::Flag::NormalTexture, 1}
#endif
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 years ago
};
Shaders: test compilation of Phong shader. Currently fails for some combinations.
13 years ago
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
constexpr struct {
const char* name;
PhongGL::Flags flags;
UnsignedInt lightCount, materialCount, drawCount;
} ConstructUniformBuffersData[]{
{"classic fallback", {}, 1, 1, 1},
{"", PhongGL::Flag::UniformBuffers, 1, 1, 1},
Shaders: ye, SwiftShader, thanks for reminding me of the harsh reality. 256 vectors in total is really damn low, guess I'll have to optimize the remaining uniform structures to deduplicate the redundant material info.
5 years ago
/* SwiftShader has 256 uniform vectors at most, per-3D-draw is 4+4,
per-material 4, per-light 4 plus 4 for projection */
{"multiple lights, materials, draws", PhongGL::Flag::UniformBuffers, 8, 8, 24},
{"zero lights", PhongGL::Flag::UniformBuffers, 0, 16, 24},
Shaders: add UBO support to all shaders.
5 years ago
{"ambient + diffuse + specular texture", PhongGL::Flag::UniformBuffers|PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::SpecularTexture, 1, 1, 1},
{"ambient + diffuse + specular texture + texture transformation", PhongGL::Flag::UniformBuffers|PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::SpecularTexture|PhongGL::Flag::TextureTransformation, 1, 1, 1},
{"normal texture", PhongGL::Flag::UniformBuffers|PhongGL::Flag::NormalTexture, 1, 1, 1},
{"normal texture + separate bitangents", PhongGL::Flag::UniformBuffers|PhongGL::Flag::NormalTexture|PhongGL::Flag::Bitangent, 1, 1, 1},
{"alpha mask", PhongGL::Flag::UniformBuffers|PhongGL::Flag::AlphaMask, 1, 1, 1},
Shaders: multidraw support in all builtin shaders.
5 years ago
{"object ID", PhongGL::Flag::UniformBuffers|PhongGL::Flag::ObjectId, 1, 1, 1},
{"multidraw with all the things", PhongGL::Flag::MultiDraw|PhongGL::Flag::TextureTransformation|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::AmbientTexture|PhongGL::Flag::SpecularTexture|PhongGL::Flag::NormalTexture|PhongGL::Flag::AlphaMask|PhongGL::Flag::ObjectId|PhongGL::Flag::InstancedTextureOffset|PhongGL::Flag::InstancedTransformation|PhongGL::Flag::InstancedObjectId, 8, 16, 24}
Shaders: add UBO support to all shaders.
5 years ago
};
Shaders: ensure the ObjectId and Bitangent attribs are not used together. These deliberately share the same binding (because there's very little space), but the shader wasn't guarding that. Discovered completely by accident when adding tests for "multidraw with all the things" -- Mesa gives just a warning, but ANGLE straight out fails the shader compilation, so better have an assert there.
5 years ago
#endif
constexpr struct {
const char* name;
PhongGL::Flags flags;
const char* message;
} ConstructInvalidData[] {
{"texture transformation but not textured",
PhongGL::Flag::TextureTransformation,
"texture transformation enabled but the shader is not textured"},
#ifndef MAGNUM_TARGET_GLES2
{"conflicting bitangent and instanced object id attribute",
PhongGL::Flag::Bitangent|PhongGL::Flag::InstancedObjectId,
"Bitangent attribute binding conflicts with the ObjectId attribute, use a Tangent4 attribute with instanced object ID rendering instead"},
#endif
};
Shaders: add UBO support to all shaders.
5 years ago
Shaders: ensure the ObjectId and Bitangent attribs are not used together. These deliberately share the same binding (because there's very little space), but the shader wasn't guarding that. Discovered completely by accident when adding tests for "multidraw with all the things" -- Mesa gives just a warning, but ANGLE straight out fails the shader compilation, so better have an assert there.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: add UBO support to all shaders.
5 years ago
constexpr struct {
const char* name;
PhongGL::Flags flags;
UnsignedInt lightCount, materialCount, drawCount;
const char* message;
} ConstructUniformBuffersInvalidData[]{
{"zero draws", PhongGL::Flag::UniformBuffers, 1, 1, 0,
"draw count can't be zero"},
{"zero materials", PhongGL::Flag::UniformBuffers, 1, 0, 1,
"material count can't be zero"},
};
#endif
Shaders: rendering tests for Phong shader.
7 years ago
using namespace Math::Literals;
const struct {
const char* name;
Deg rotation;
Shaders: alpha doesn't make sense for light colors. I basically deprecated half of the Phong shader API. Sigh. Enjoy updating your code.
6 years ago
Color3 lightColor1, lightColor2;
Shaders: rendering tests for Phong shader.
7 years ago
Float lightPosition1, lightPosition2;
} RenderColoredData[]{
{"", {}, 0x993366_rgbf, 0x669933_rgbf, -3.0f, 3.0f},
{"flip lights", {}, 0x669933_rgbf, 0x993366_rgbf, 3.0f, -3.0f},
{"rotated", 45.0_degf, 0x993366_rgbf, 0x669933_rgbf, -3.0f, 3.0f}
};
constexpr struct {
const char* name;
bool multiBind;
} RenderSinglePixelTexturedData[]{
{"", false},
{"multi bind", true}
};
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 {
Shaders: rendering tests for Phong shader.
7 years ago
const char* name;
const char* expected;
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
PhongGL::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;
Shaders: rendering tests for Phong shader.
7 years ago
} 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
{"all", "textured.tga", PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::SpecularTexture, {}},
{"ambient", "textured-ambient.tga", PhongGL::Flag::AmbientTexture, {}},
{"diffuse", "textured-diffuse.tga", PhongGL::Flag::DiffuseTexture, {}},
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
{"diffuse transformed", "textured-diffuse-transformed.tga",
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
PhongGL::Flag::DiffuseTexture|PhongGL::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})
},
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
{"specular", "textured-specular.tga", PhongGL::Flag::SpecularTexture, {}}
Shaders: rendering tests for Phong shader.
7 years ago
};
/* MSVC 2015 doesn't like constexpr here due to the angles */
const struct {
const char* name;
Shaders: add a normal texture scale parameter to Phong. It's needed to support the new material attributes supported by glTF. The test output is slightly different as the normal coming from the texture wasn't normalized before.
6 years ago
const char* expected;
Shaders: test Phong normal texture multi-bind as well.
7 years ago
bool multiBind;
Shaders: rendering tests for Phong shader.
7 years ago
Deg rotation;
Shaders: add a normal texture scale parameter to Phong. It's needed to support the new material attributes supported by glTF. The test output is slightly different as the normal coming from the texture wasn't normalized before.
6 years ago
Float scale;
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
Vector4 tangent;
Vector3 bitangent;
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
PhongGL::Tangent4::Components tangentComponents;
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
bool flipNormalY;
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
PhongGL::Flags flags;
Shaders: rendering tests for Phong shader.
7 years ago
} RenderTexturedNormalData[]{
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"", "textured-normal.tga", false, {}, 1.0f,
{1.0f, 0.0f, 0.0f, 1.0f}, {},
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
PhongGL::Tangent4::Components::Four, false, {}},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"multi bind", "textured-normal.tga", true, {}, 1.0f,
{1.0f, 0.0f, 0.0f, 1.0f}, {},
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
PhongGL::Tangent4::Components::Four, false, {}},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"rotated 90°", "textured-normal.tga", false, 90.0_degf, 1.0f,
{1.0f, 0.0f, 0.0f, 1.0f}, {},
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
PhongGL::Tangent4::Components::Four, false, {}},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"rotated -90°", "textured-normal.tga", false, -90.0_degf, 1.0f,
{1.0f, 0.0f, 0.0f, 1.0f}, {},
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
PhongGL::Tangent4::Components::Four, false, {}},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"0.5 scale", "textured-normal0.5.tga", false, {}, 0.5f,
{1.0f, 0.0f, 0.0f, 1.0f}, {},
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
PhongGL::Tangent4::Components::Four, false, {}},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"0.0 scale", "textured-normal0.0.tga", false, {}, 0.0f,
{1.0f, 0.0f, 0.0f, 1.0f}, {},
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
PhongGL::Tangent4::Components::Four, false, {}},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
/* The fourth component, if missing, gets automatically filled up to 1,
so this should work */
{"implicit bitangent direction", "textured-normal.tga", false, {}, 1.0f,
{1.0f, 0.0f, 0.0f, 0.0f}, {},
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
PhongGL::Tangent4::Components::Three, false, {}},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"separate bitangents", "textured-normal.tga", false, {}, 1.0f,
{1.0f, 0.0f, 0.0f, 1.0f}, {0.0f, 1.0f, 0.0f},
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
PhongGL::Tangent4::Components::Three, false,
PhongGL::Flag::Bitangent},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"right-handed, flipped Y", "textured-normal-left.tga", false, {}, 1.0f,
{1.0f, 0.0f, 0.0f, 1.0f}, {},
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
PhongGL::Tangent4::Components::Four, true, {}},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"left-handed", "textured-normal-left.tga", false, {}, 1.0f,
{1.0f, 0.0f, 0.0f, -1.0f}, {},
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
PhongGL::Tangent4::Components::Four, false, {}},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"left-handed, separate bitangents", "textured-normal-left.tga", false, {}, 1.0f,
{1.0f, 0.0f, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f},
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
PhongGL::Tangent4::Components::Three, false,
PhongGL::Flag::Bitangent},
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
{"left-handed, flipped Y", "textured-normal.tga", false, {}, 1.0f,
{1.0f, 0.0f, 0.0f, -1.0f}, {},
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
PhongGL::Tangent4::Components::Four, true, {}}
Shaders: rendering tests for Phong shader.
7 years ago
};
const struct {
const char* name;
const char* expected;
Float shininess;
Color4 specular;
} RenderShininessData[] {
{"80", "shininess80.tga", 80.0f, 0xffffff_rgbf},
{"10", "shininess10.tga", 10.0f, 0xffffff_rgbf},
{"0", "shininess0.tga", 0.0f, 0xffffff_rgbf},
{"0.001", "shininess0.tga", 0.001f, 0xffffff_rgbf},
{"black specular", "shininess-black-specular.tga", 80.0f, 0x000000_rgbf}
};
const struct {
const char* name;
const char* expected;
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
PhongGL::Flags flags;
Shaders: rendering tests for Phong shader.
7 years ago
Float threshold;
const char* ambientTexture;
const char* diffuseTexture;
Color4 ambientColor;
Color4 diffuseColor;
} RenderAlphaData[] {
/* All those deliberately have a non-white diffuse in order to match the
expected data from textured() */
{"none, separate", "PhongTestFiles/textured-diffuse.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
PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture, 0.0f,
Shaders: rendering tests for Phong shader.
7 years ago
"alpha-texture.tga", "diffuse-texture.tga",
0xffffffff_rgbaf, 0x9999ff00_rgbaf},
{"none, combined", "PhongTestFiles/textured-diffuse.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
PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture, 0.0f,
Shaders: rendering tests for Phong shader.
7 years ago
"diffuse-alpha-texture.tga", "diffuse-alpha-texture.tga",
0x000000ff_rgbaf, 0x9999ff00_rgbaf},
{"blending, separate", "PhongTestFiles/textured-diffuse-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
PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture, 0.0f,
Shaders: rendering tests for Phong shader.
7 years ago
"alpha-texture.tga", "diffuse-texture.tga",
0xffffffff_rgbaf, 0x9999ff00_rgbaf},
{"blending, combined", "PhongTestFiles/textured-diffuse-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
PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture, 0.0f,
Shaders: rendering tests for Phong shader.
7 years ago
"diffuse-alpha-texture.tga", "diffuse-alpha-texture.tga",
0x000000ff_rgbaf, 0x9999ff00_rgbaf},
{"masking 0.0, separate", "PhongTestFiles/textured-diffuse.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
PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::AlphaMask, 0.0f,
Shaders: rendering tests for Phong shader.
7 years ago
"alpha-texture.tga", "diffuse-texture.tga",
0xffffffff_rgbaf, 0x9999ff00_rgbaf},
{"masking 0.5, separate", "PhongTestFiles/textured-diffuse-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
PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::AlphaMask, 0.5f,
Shaders: rendering tests for Phong shader.
7 years ago
"alpha-texture.tga", "diffuse-texture.tga",
0xffffffff_rgbaf, 0x9999ff00_rgbaf},
{"masking 0.5, combined", "PhongTestFiles/textured-diffuse-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
PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::AlphaMask, 0.5f,
Shaders: rendering tests for Phong shader.
7 years ago
"diffuse-alpha-texture.tga", "diffuse-alpha-texture.tga",
0x000000ff_rgbaf, 0x9999ff00_rgbaf},
{"masking 1.0, separate", "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
PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::AlphaMask, 1.0f,
Shaders: rendering tests for Phong shader.
7 years ago
"alpha-texture.tga", "diffuse-texture.tga",
0xffffffff_rgbaf, 0x9999ff00_rgbaf}
};
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
const struct {
const char* name;
const char* file;
Vector4 position;
Shaders: add an ability to control specular light color to Phong.
6 years ago
Color3 specularColor, lightSpecularColor;
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
Float intensity;
Float range;
Containers::Array<std::pair<Vector2i, Color3ub>> picks;
} RenderLightsData[] {
{"directional", "light-directional.tga",
Shaders: add an ability to control specular light color to Phong.
6 years ago
{1.0f, -1.5f, 0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f},
1.0f, Constants::inf(),
Adapt to Corrade changes.
5 years ago
{InPlaceInit, {
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Ambient isn't affected by light direction, otherwise it's a
dot product of a normalized direction */
{{40, 40}, 0x222222_rgb + 0xff8080_rgb*dot(Vector3{1.0f, -1.5f, 0.5f}.normalized(), Vector3::zAxis())},
/* and it's the same across the whole surface */
{{70, 70}, 0x222222_rgb + 0xff8080_rgb*dot(Vector3{1.0f, -1.5f, 0.5f}.normalized(), Vector3::zAxis())},
}}},
/* These two should produce the same output as the *normalized* dot product
is the same */
{"directional, from the other side", "light-directional.tga",
Shaders: add an ability to control specular light color to Phong.
6 years ago
{-1.0f, 1.5f, 0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f},
1.0f, Constants::inf(), {}},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
{"directional, scaled direction", "light-directional.tga",
Shaders: add an ability to control specular light color to Phong.
6 years ago
{10.0f, -15.0f, 5.0f, 0.0f}, Color3{1.0f}, Color3{1.0f},
1.0f, Constants::inf(), {}},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Range should have no effect either, especially zero range should not
cause any NaNs */
{"directional, range=0.1", "light-directional.tga",
Shaders: add an ability to control specular light color to Phong.
6 years ago
{1.0f, -1.5f, 0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f},
1.0f, 1.0f, {}},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
{"directional, range=0", "light-directional.tga",
Shaders: add an ability to control specular light color to Phong.
6 years ago
{1.0f, -1.5f, 0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f},
1.0f, 1.0f, {}},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Light from the other side doesn't contribute anything */
{"directional, from back", "light-none.tga",
Shaders: add an ability to control specular light color to Phong.
6 years ago
{-1.0f, 1.5f, -0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f},
1.0f, Constants::inf(),
Adapt to Corrade changes.
5 years ago
{InPlaceInit, {
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Only ambient color left */
{{40, 40}, 0x222222_rgb}
}}},
/* This is the same as above, except that twice the intensity causes it to
be 2x brighter */
{"directional, intensity=2", "light-directional-intensity2.tga",
Shaders: add an ability to control specular light color to Phong.
6 years ago
{1.0f, -1.5f, 0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f},
2.0f, 1.0f,
Adapt to Corrade changes.
5 years ago
{InPlaceInit, {
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
{{40, 40}, 0x222222_rgb + 0xff8080_rgb*dot(Vector3{1.0f, -1.5f, 0.5f}.normalized(), Vector3::zAxis())*2.0f}
}}},
{"point", "light-point.tga",
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, Color3{1.0f},
Shaders: add an ability to control specular light color to Phong.
6 years ago
1.0f, Constants::inf(),
Adapt to Corrade changes.
5 years ago
{InPlaceInit, {
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* The range is inf, so it doesn't get fully ambient even at the
edge */
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{{8, 71}, 0x2c2727_rgb},
/* Closest to the light */
{{63, 16}, 0x222222_rgb + 0xff8080_rgb/(1 + 0.75f*0.75f)},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Specular highlight */
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{{60, 19}, 0xc47575_rgb}
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
}}},
Shaders: add an ability to control specular light color to Phong.
6 years ago
{"point, specular material color", "light-point-specular-color.tga",
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{0.75f, -0.75f, -0.75f, 1.0f}, 0x80ff80_rgbf, Color3{1.0f},
Shaders: add an ability to control specular light color to Phong.
6 years ago
1.0f, Constants::inf(),
Adapt to Corrade changes.
5 years ago
{InPlaceInit, {
Shaders: add an ability to control specular light color to Phong.
6 years ago
/* Colored specular highlight */
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{{60, 19}, 0xc27573_rgb}
Shaders: add an ability to control specular light color to Phong.
6 years ago
}}},
{"point, specular light color", "light-point-specular-color.tga",
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, 0x80ff80_rgbf,
Shaders: add an ability to control specular light color to Phong.
6 years ago
1.0f, Constants::inf(),
Adapt to Corrade changes.
5 years ago
{InPlaceInit, {
Shaders: add an ability to control specular light color to Phong.
6 years ago
/* Colored specular highlight */
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{{60, 19}, 0xc27573_rgb}
Shaders: add an ability to control specular light color to Phong.
6 years ago
}}},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
{"point, attenuated specular", "light-point-attenuated-specular.tga",
Shaders: add an ability to control specular light color to Phong.
6 years ago
{1.0f, -1.0f, -0.25f, 1.0f}, Color3{1.0f}, Color3{1.0f},
1.0f, 2.5f,
Adapt to Corrade changes.
5 years ago
{InPlaceInit, {
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Specular highlight shouldn't be brighter than the attenuated
intensity */
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{{57, 22}, 0xa68787_rgb}
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
}}},
Shaders: add an ability to control specular light color to Phong.
6 years ago
{"point, range=1.5, specular color", "light-point-range1.5.tga",
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, 0x80ff80_rgbf,
Shaders: add an ability to control specular light color to Phong.
6 years ago
1.0f, 1.5f,
Adapt to Corrade changes.
5 years ago
{InPlaceInit, {
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Color goes back to ambient at distance = 1.5 */
{{59, 60}, 0x222222_rgb},
{{29, 50}, 0x222222_rgb},
{{19, 14}, 0x222222_rgb},
/* But the center and specular stays ~ the same */
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{{63, 16}, 0xb16a6a_rgb},
{{60, 19}, 0xad6a69_rgb}
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
}}},
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{"point, intensity=10, range=1.0", "light-point-intensity10-range1.0.tga",
{0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, Color3{1.0f},
10.0f, 1.0f, {}},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Range ends right at the surface, so no contribution */
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{"point, range=0.75", "light-none.tga",
{0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, Color3{1.0f},
1.0f, 0.75f, {}},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Zero range should not cause any NaNs, so the ambient contribution is
still there */
{"point, range=0.0", "light-none.tga",
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, Color3{1.0f},
Shaders: add an ability to control specular light color to Phong.
6 years ago
1.0f, 0.0f, {}},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
/* Distance is 0, which means the direction is always prependicular and
thus contributes nothing */
{"point, distance=0", "light-none.tga",
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
{0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, Color3{1.0f},
Shaders: add an ability to control specular light color to Phong.
6 years ago
1.0f, 0.0f, {}}
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
};
Shaders: implement instancing in Phong.
6 years ago
constexpr struct {
const char* name;
const char* file;
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
PhongGL::Flags flags;
Shaders: implement instancing in Phong.
6 years ago
Float maxThreshold, meanThreshold;
} RenderInstancedData[] {
{"diffuse", "instanced.tga", {},
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* AMD has one off pixel; SwiftShader a bit more */
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
96.34f, 0.113f,
Shaders: implement instancing in Phong.
6 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage */
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
96.34f, 0.113f,
Shaders: implement instancing in Phong.
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
{"diffuse + normal", "instanced-normal.tga", PhongGL::Flag::NormalTexture,
Shaders: implement instancing in Phong.
6 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
/* AMD has one off pixel, llvmpipe more */
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
96.0f, 0.333f,
Shaders: implement instancing in Phong.
6 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage */
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
96.0f, 0.333f,
Shaders: implement instancing in Phong.
6 years ago
#endif
}
};
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
constexpr struct {
const char* name;
const char* expected;
PhongGL::Flags flags;
UnsignedInt lightCount, materialCount, drawCount;
UnsignedInt uniformIncrement;
Float maxThreshold, meanThreshold;
} RenderMultiData[] {
{"bind with offset, colored", "multidraw.tga",
{},
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, 1, 1, 16,
/* Minor differences on ARM Mali */
3.34f, 0.01f},
Shaders: add UBO support to all shaders.
5 years ago
{"bind with offset, textured", "multidraw-textured.tga",
PhongGL::Flag::TextureTransformation|PhongGL::Flag::DiffuseTexture,
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, 1, 1, 16,
/* Minor differences on ARM Mali */
4.67f, 0.02f},
Shaders: add UBO support to all shaders.
5 years ago
{"draw offset, colored", "multidraw.tga",
{},
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
4, 2, 3, 1,
/* Minor differences on ARM Mali */
3.34f, 0.01f},
Shaders: add UBO support to all shaders.
5 years ago
{"draw offset, textured", "multidraw-textured.tga",
PhongGL::Flag::TextureTransformation|PhongGL::Flag::DiffuseTexture,
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
4, 2, 3, 1,
/* Minor differences on ARM Mali */
4.67f, 0.02f},
Shaders: multidraw support in all builtin shaders.
5 years ago
{"multidraw, colored", "multidraw.tga",
PhongGL::Flag::MultiDraw,
4, 2, 3, 1,
/* Minor differences on ARM Mali */
3.34f, 0.01f},
{"multidraw, textured", "multidraw-textured.tga",
PhongGL::Flag::MultiDraw|PhongGL::Flag::TextureTransformation|PhongGL::Flag::DiffuseTexture,
4, 2, 3, 1,
/* Minor differences on ARM Mali */
4.67f, 0.02f},
Shaders: add UBO support to all shaders.
5 years ago
};
#endif
Shaders: simplify the Phong construction test a bit. Ugh.
8 years ago
PhongGLTest::PhongGLTest() {
Shaders: add UBO support to all shaders.
5 years ago
addInstancedTests({&PhongGLTest::construct},
Containers::arraySize(ConstructData));
#ifndef MAGNUM_TARGET_GLES2
addInstancedTests({&PhongGLTest::constructUniformBuffers},
Containers::arraySize(ConstructUniformBuffersData));
#endif
Shaders: test compilation of Phong shader. Currently fails for some combinations.
13 years ago
Shaders: add UBO support to all shaders.
5 years ago
addTests({
&PhongGLTest::constructMove,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::constructMoveUniformBuffers,
#endif
Shaders: ensure the ObjectId and Bitangent attribs are not used together. These deliberately share the same binding (because there's very little space), but the shader wasn't guarding that. Discovered completely by accident when adding tests for "multidraw with all the things" -- Mesa gives just a warning, but ANGLE straight out fails the shader compilation, so better have an assert there.
5 years ago
});
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 years ago
Shaders: ensure the ObjectId and Bitangent attribs are not used together. These deliberately share the same binding (because there's very little space), but the shader wasn't guarding that. Discovered completely by accident when adding tests for "multidraw with all the things" -- Mesa gives just a warning, but ANGLE straight out fails the shader compilation, so better have an assert there.
5 years ago
addInstancedTests({&PhongGLTest::constructInvalid},
Containers::arraySize(ConstructInvalidData));
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
addInstancedTests({
&PhongGLTest::constructUniformBuffersInvalid},
Containers::arraySize(ConstructUniformBuffersInvalidData));
#endif
addTests({
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::setUniformUniformBuffersEnabled,
&PhongGLTest::bindBufferUniformBuffersNotEnabled,
#endif
&PhongGLTest::bindTexturesNotEnabled,
&PhongGLTest::setAlphaMaskNotEnabled,
&PhongGLTest::setTextureMatrixNotEnabled,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::bindTextureTransformBufferNotEnabled,
#endif
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::setObjectIdNotEnabled,
#endif
&PhongGLTest::setWrongLightCount,
&PhongGLTest::setWrongLightId,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::setWrongDrawOffset
#endif
});
Shaders: rendering tests for Phong shader.
7 years ago
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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderDefaults,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderDefaults<PhongGL::Flag::UniformBuffers>
#endif
},
Shaders: rendering tests for Phong shader.
7 years ago
&PhongGLTest::renderSetup,
&PhongGLTest::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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderColored,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderColored<PhongGL::Flag::UniformBuffers>
#endif
},
Shaders: rendering tests for Phong shader.
7 years ago
Containers::arraySize(RenderColoredData),
&PhongGLTest::renderSetup,
&PhongGLTest::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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderSinglePixelTextured,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderSinglePixelTextured<PhongGL::Flag::UniformBuffers>
#endif
},
Shaders: rendering tests for Phong shader.
7 years ago
Containers::arraySize(RenderSinglePixelTexturedData),
&PhongGLTest::renderSetup,
&PhongGLTest::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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderTextured,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderTextured<PhongGL::Flag::UniformBuffers>
#endif
},
Shaders: rendering tests for Phong shader.
7 years ago
Containers::arraySize(RenderTexturedData),
&PhongGLTest::renderSetup,
&PhongGLTest::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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderTexturedNormal,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderTexturedNormal<PhongGL::Flag::UniformBuffers>
#endif
},
Shaders: rendering tests for Phong shader.
7 years ago
Containers::arraySize(RenderTexturedNormalData),
&PhongGLTest::renderSetup,
&PhongGLTest::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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderVertexColor<Color3>,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderVertexColor<Color3, PhongGL::Flag::UniformBuffers>,
#endif
&PhongGLTest::renderVertexColor<Color4>,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderVertexColor<Color4, PhongGL::Flag::UniformBuffers>,
#endif
},
Shaders: vertex color support in Phong and Flat.
7 years ago
&PhongGLTest::renderSetup,
&PhongGLTest::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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderShininess,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderShininess<PhongGL::Flag::UniformBuffers>,
#endif
},
Shaders: rendering tests for Phong shader.
7 years ago
Containers::arraySize(RenderShininessData),
&PhongGLTest::renderSetup,
&PhongGLTest::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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderAlpha,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderAlpha<PhongGL::Flag::UniformBuffers>
#endif
},
Shaders: rendering tests for Phong shader.
7 years ago
Containers::arraySize(RenderAlphaData),
&PhongGLTest::renderAlphaSetup,
&PhongGLTest::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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderObjectId,
&PhongGLTest::renderObjectId<PhongGL::Flag::UniformBuffers>},
Shaders: support object ID output in Flat and Phong.
7 years ago
&PhongGLTest::renderObjectIdSetup,
&PhongGLTest::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 */
addInstancedTests<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderLights,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderLights<PhongGL::Flag::UniformBuffers>,
#endif
},
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
Containers::arraySize(RenderLightsData),
&PhongGLTest::renderSetup,
&PhongGLTest::renderTeardown);
Shaders: properly test Phong one-by-one light property setters. Testing that they don't assert *isn't* enough.
6 years ago
addTests({&PhongGLTest::renderLightsSetOneByOne,
&PhongGLTest::renderLowLightAngle},
Shaders: resetting object ID FBs isn't needed for light tests.
6 years ago
&PhongGLTest::renderSetup,
&PhongGLTest::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<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderZeroLights,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderZeroLights<PhongGL::Flag::UniformBuffers>
#endif
},
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderObjectIdSetup,
&PhongGLTest::renderObjectIdTeardown
#else
&PhongGLTest::renderSetup,
&PhongGLTest::renderTeardown
#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 */
addInstancedTests<PhongGLTest>({
Shaders: add UBO support to all shaders.
5 years ago
&PhongGLTest::renderInstanced,
#ifndef MAGNUM_TARGET_GLES2
&PhongGLTest::renderInstanced<PhongGL::Flag::UniformBuffers>,
#endif
},
Shaders: implement instancing in Phong.
6 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
&PhongGLTest::renderObjectIdSetup,
&PhongGLTest::renderObjectIdTeardown
#else
Shaders: implement instancing in Phong.
6 years ago
&PhongGLTest::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
&PhongGLTest::renderTeardown
#endif
);
Shaders: implement instancing in Phong.
6 years ago
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
addInstancedTests({&PhongGLTest::renderMulti},
Containers::arraySize(RenderMultiData),
&PhongGLTest::renderObjectIdSetup,
&PhongGLTest::renderObjectIdTeardown);
#endif
Shaders: rendering tests for Phong 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 Phong 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 Phong 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 Phong shader. Currently fails for some combinations.
13 years ago
}
Shaders: simplify the Phong construction test a bit. Ugh.
8 years ago
void PhongGLTest::construct() {
auto&& data = ConstructData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: test compilation of Phong shader. Currently fails for some combinations.
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 & PhongGL::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
PhongGL shader{data.flags, data.lightCount};
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
CORRADE_COMPARE(shader.flags(), data.flags);
Shaders: support multiple lights in Phong.
8 years ago
CORRADE_COMPARE(shader.lightCount(), data.lightCount);
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: test compilation of Phong shader. Currently fails for some combinations.
13 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
void PhongGLTest::constructUniformBuffers() {
auto&& data = ConstructUniformBuffersData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES
if((data.flags & PhongGL::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 & PhongGL::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 >= PhongGL::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
PhongGL shader{data.flags, data.lightCount, data.materialCount, data.drawCount};
CORRADE_COMPARE(shader.flags(), data.flags);
CORRADE_COMPARE(shader.lightCount(), data.lightCount);
CORRADE_COMPARE(shader.materialCount(), data.materialCount);
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: 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
void PhongGLTest::constructMove() {
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
PhongGL a{PhongGL::Flag::AlphaMask, 3};
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
PhongGL 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(), PhongGL::Flag::AlphaMask);
Shaders: support multiple lights in Phong.
8 years ago
CORRADE_COMPARE(b.lightCount(), 3);
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
PhongGL 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(), PhongGL::Flag::AlphaMask);
Shaders: support multiple lights in Phong.
8 years ago
CORRADE_COMPARE(c.lightCount(), 3);
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
void PhongGLTest::constructMoveUniformBuffers() {
#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
PhongGL a{PhongGL::Flag::UniformBuffers, 3, 2, 5};
const GLuint id = a.id();
CORRADE_VERIFY(id);
MAGNUM_VERIFY_NO_GL_ERROR();
PhongGL b{std::move(a)};
CORRADE_COMPARE(b.id(), id);
CORRADE_COMPARE(b.flags(), PhongGL::Flag::UniformBuffers);
CORRADE_COMPARE(b.lightCount(), 3);
CORRADE_COMPARE(b.materialCount(), 2);
CORRADE_COMPARE(b.drawCount(), 5);
CORRADE_VERIFY(!a.id());
PhongGL c{NoCreate};
c = std::move(b);
CORRADE_COMPARE(c.id(), id);
CORRADE_COMPARE(c.flags(), PhongGL::Flag::UniformBuffers);
CORRADE_COMPARE(c.lightCount(), 3);
CORRADE_COMPARE(c.materialCount(), 2);
CORRADE_COMPARE(c.drawCount(), 5);
CORRADE_VERIFY(!b.id());
}
#endif
Shaders: ensure the ObjectId and Bitangent attribs are not used together. These deliberately share the same binding (because there's very little space), but the shader wasn't guarding that. Discovered completely by accident when adding tests for "multidraw with all the things" -- Mesa gives just a warning, but ANGLE straight out fails the shader compilation, so better have an assert there.
5 years ago
void PhongGLTest::constructInvalid() {
auto&& data = ConstructInvalidData[testCaseInstanceId()];
setTestCaseDescription(data.name);
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: ensure the ObjectId and Bitangent attribs are not used together. These deliberately share the same binding (because there's very little space), but the shader wasn't guarding that. Discovered completely by accident when adding tests for "multidraw with all the things" -- Mesa gives just a warning, but ANGLE straight out fails the shader compilation, so better have an assert there.
5 years ago
PhongGL{data.flags};
CORRADE_COMPARE(out.str(), Utility::formatString(
"Shaders::PhongGL: {}\n", data.message));
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
void PhongGLTest::constructUniformBuffersInvalid() {
auto&& data = ConstructUniformBuffersInvalidData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#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};
PhongGL{data.flags, data.lightCount, data.materialCount, data.drawCount};
CORRADE_COMPARE(out.str(), Utility::formatString(
"Shaders::PhongGL: {}\n", data.message));
}
#endif
#ifndef MAGNUM_TARGET_GLES2
void PhongGLTest::setUniformUniformBuffersEnabled() {
#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};
PhongGL shader{PhongGL::Flag::UniformBuffers};
shader.setAmbientColor({})
.setDiffuseColor({})
.setNormalTextureScale({})
.setSpecularColor({})
.setShininess({})
.setAlphaMask({})
.setObjectId({})
.setTransformationMatrix({})
.setNormalMatrix({})
.setProjectionMatrix({})
.setTextureMatrix({})
.setLightPositions(std::initializer_list<Vector4>{})
.setLightPosition(0, Vector4{})
.setLightColors(std::initializer_list<Color3>{})
.setLightColor(0, Color3{})
.setLightSpecularColors({})
.setLightSpecularColor(0, {})
.setLightRanges({})
.setLightRange(0, {});
CORRADE_COMPARE(out.str(),
"Shaders::PhongGL::setAmbientColor(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setDiffuseColor(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setNormalTextureScale(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setSpecularColor(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setShininess(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setAlphaMask(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setObjectId(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setTransformationMatrix(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setNormalMatrix(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setProjectionMatrix(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setTextureMatrix(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setLightPositions(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setLightPosition(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setLightColors(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setLightColor(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setLightSpecularColors(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setLightSpecularColor(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setLightRanges(): the shader was created with uniform buffers enabled\n"
"Shaders::PhongGL::setLightRange(): the shader was created with uniform buffers enabled\n");
}
void PhongGLTest::bindBufferUniformBuffersNotEnabled() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
std::ostringstream out;
Error redirectError{&out};
GL::Buffer buffer;
PhongGL shader;
shader.bindProjectionBuffer(buffer)
.bindProjectionBuffer(buffer, 0, 16)
.bindTransformationBuffer(buffer)
.bindTransformationBuffer(buffer, 0, 16)
.bindDrawBuffer(buffer)
.bindDrawBuffer(buffer, 0, 16)
.bindTextureTransformationBuffer(buffer)
.bindTextureTransformationBuffer(buffer, 0, 16)
.bindMaterialBuffer(buffer)
.bindMaterialBuffer(buffer, 0, 16)
.bindLightBuffer(buffer)
.bindLightBuffer(buffer, 0, 16)
.setDrawOffset(0);
CORRADE_COMPARE(out.str(),
"Shaders::PhongGL::bindProjectionBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindProjectionBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindTransformationBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindTransformationBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindDrawBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindDrawBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindTextureTransformationBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindTextureTransformationBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindMaterialBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindMaterialBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindLightBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::bindLightBuffer(): the shader was not created with uniform buffers enabled\n"
"Shaders::PhongGL::setDrawOffset(): the shader was not created with uniform buffers enabled\n");
}
#endif
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 years ago
void PhongGLTest::bindTexturesNotEnabled() {
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 on Phong::bindTexture*() if no texture was enabled.
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
PhongGL shader;
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 years ago
shader.bindAmbientTexture(texture)
.bindDiffuseTexture(texture)
.bindSpecularTexture(texture)
Shaders: add normal texture support to Phong. Note -- since there are no visual tests for Phong yet, this is done in the least intrusive manner to avoid breaking current functionality. It's likely very underperforming due to the matric calculation per fragment, it'll get optimized once I have proper tests.
7 years ago
.bindNormalTexture(texture)
Shaders: add a normal texture scale parameter to Phong. It's needed to support the new material attributes supported by glTF. The test output is slightly different as the normal coming from the texture wasn't normalized before.
6 years ago
.setNormalTextureScale(0.5f)
Shaders: add normal texture support to Phong. Note -- since there are no visual tests for Phong yet, this is done in the least intrusive manner to avoid breaking current functionality. It's likely very underperforming due to the matric calculation per fragment, it'll get optimized once I have proper tests.
7 years ago
.bindTextures(&texture, &texture, &texture, &texture);
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
8 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::PhongGL::bindAmbientTexture(): the shader was not created with ambient texture enabled\n"
"Shaders::PhongGL::bindDiffuseTexture(): the shader was not created with diffuse texture enabled\n"
"Shaders::PhongGL::bindSpecularTexture(): the shader was not created with specular texture enabled\n"
"Shaders::PhongGL::bindNormalTexture(): the shader was not created with normal texture enabled\n"
"Shaders::PhongGL::setNormalTextureScale(): the shader was not created with normal texture enabled\n"
"Shaders::PhongGL::bindTextures(): the shader was not created with any textures enabled\n");
Shaders: assert on Phong::bindTexture*() if no texture was enabled.
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
void PhongGLTest::setAlphaMaskNotEnabled() {
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
PhongGL 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::PhongGL::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
void PhongGLTest::setTextureMatrixNotEnabled() {
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
PhongGL 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::PhongGL::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
void PhongGLTest::bindTextureTransformBufferNotEnabled() {
#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};
PhongGL shader{PhongGL::Flag::UniformBuffers};
shader.bindTextureTransformationBuffer(buffer)
.bindTextureTransformationBuffer(buffer, 0, 16);
CORRADE_COMPARE(out.str(),
"Shaders::PhongGL::bindTextureTransformationBuffer(): the shader was not created with texture transformation enabled\n"
"Shaders::PhongGL::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
void PhongGLTest::setObjectIdNotEnabled() {
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
PhongGL 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::PhongGL::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: support multiple lights in Phong.
8 years ago
void PhongGLTest::setWrongLightCount() {
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 multiple lights in Phong.
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
PhongGL{{}, 5}
Shaders: properly test Phong one-by-one light property setters. Testing that they don't assert *isn't* enough.
6 years ago
.setLightColors({Color3{}})
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
.setLightPositions({Vector4{}})
.setLightRanges({0.0f});
Shaders: support multiple lights in Phong.
8 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::PhongGL::setLightColors(): expected 5 items but got 1\n"
"Shaders::PhongGL::setLightPositions(): expected 5 items but got 1\n"
"Shaders::PhongGL::setLightRanges(): expected 5 items but got 1\n");
Shaders: support multiple lights in Phong.
8 years ago
}
void PhongGLTest::setWrongLightId() {
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 multiple lights in Phong.
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
PhongGL{{}, 3}
Shaders: alpha doesn't make sense for light colors. I basically deprecated half of the Phong shader API. Sigh. Enjoy updating your code.
6 years ago
.setLightColor(3, Color3{})
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
.setLightPosition(3, Vector4{})
.setLightRange(3, 0.0f);
Shaders: support multiple lights in Phong.
8 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::PhongGL::setLightColor(): light ID 3 is out of bounds for 3 lights\n"
"Shaders::PhongGL::setLightPosition(): light ID 3 is out of bounds for 3 lights\n"
"Shaders::PhongGL::setLightRange(): light ID 3 is out of bounds for 3 lights\n");
Shaders: support multiple lights in Phong.
8 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
void PhongGLTest::setWrongDrawOffset() {
#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};
PhongGL{PhongGL::Flag::UniformBuffers, 1, 2, 5}
.setDrawOffset(5);
CORRADE_COMPARE(out.str(),
"Shaders::PhongGL::setDrawOffset(): draw offset 5 is out of bounds for 5 draws\n");
}
#endif
Shaders: rendering tests for Phong shader.
7 years ago
constexpr Vector2i RenderSize{80, 80};
void PhongGLTest::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 PhongGLTest::renderTeardown() {
_framebuffer = GL::Framebuffer{NoCreate};
Shaders: destruct test scaffolding in reverse order.
7 years ago
_color = GL::Renderbuffer{NoCreate};
Shaders: rendering tests for Phong shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag> void PhongGLTest::renderDefaults() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == PhongGL::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: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
Shaders: rendering tests for Phong shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
PhongGL shader{flag};
if(flag == PhongGL::Flag{}) {
shader.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}
}};
shader
.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Phong 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 Phong shader.
7 years ago
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has 6 different pixels on the edges and a bunch of small
rounding errors */
const Float maxThreshold = 31.0f, meanThreshold = 0.122f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 31.0f, meanThreshold = 4.142f;
#endif
Shaders: rendering tests for Phong 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, "PhongTestFiles/defaults.tga"),
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Phong shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag> void PhongGLTest::renderColored() {
Shaders: rendering tests for Phong shader.
7 years ago
auto&& data = RenderColoredData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == PhongGL::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 Phong shader.
7 years ago
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
Shaders: add UBO support to all shaders.
5 years ago
PhongGL shader{flag, 2};
if(flag == PhongGL::Flag{}) {
shader
.setLightColors({data.lightColor1, data.lightColor2})
.setLightPositions({{data.lightPosition1, -3.0f, 2.0f, 0.0f},
{data.lightPosition2, -3.0f, 2.0f, 0.0f}})
.setAmbientColor(0x330033_rgbf)
.setDiffuseColor(0xccffcc_rgbf)
.setSpecularColor(0x6666ff_rgbf)
.setTransformationMatrix(Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(data.rotation))
.setNormalMatrix(Matrix4::rotationY(data.rotation).normalMatrix())
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}
.setTransformationMatrix(Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(data.rotation))
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}
.setNormalMatrix(Matrix4::rotationY(data.rotation).normalMatrix())
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
.setAmbientColor(0x330033_rgbf)
.setDiffuseColor(0xccffcc_rgbf)
.setSpecularColor(0x6666ff_rgbf)
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}
.setPosition({data.lightPosition1, -3.0f, 2.0f, 0.0f})
.setColor(data.lightColor1),
PhongLightUniform{}
.setPosition({data.lightPosition2, -3.0f, 2.0f, 0.0f})
.setColor(data.lightColor2)
}};
shader
.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Phong 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 Phong shader.
7 years ago
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has some minor rounding differences (max = 1). ARM Mali G71
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
and Apple A8 has bigger rounding differences. */
const Float maxThreshold = 8.34f, meanThreshold = 0.100f;
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 15.34f, meanThreshold = 3.33f;
#endif
Shaders: rendering tests for Phong 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, "PhongTestFiles/colored.tga"),
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Phong 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<PhongGL::Flag flag> void PhongGLTest::renderSinglePixelTextured() {
Shaders: rendering tests for Phong shader.
7 years ago
auto&& data = RenderSinglePixelTexturedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == PhongGL::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 Phong 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 Phong shader.
7 years ago
const Color4ub ambientData[]{ 0x330033_rgb };
ImageView2D ambientImage{PixelFormat::RGBA8Unorm, Vector2i{1}, ambientData};
GL::Texture2D ambient;
ambient.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGBA, Vector2i{1})
.setSubImage(0, {}, ambientImage);
const Color4ub diffuseData[]{ 0xccffcc_rgb };
ImageView2D diffuseImage{PixelFormat::RGBA8Unorm, Vector2i{1}, diffuseData};
GL::Texture2D diffuse;
diffuse.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGBA, Vector2i{1})
.setSubImage(0, {}, diffuseImage);
const Color4ub specularData[]{ 0x6666ff_rgb };
ImageView2D specularImage{PixelFormat::RGBA8Unorm, Vector2i{1}, specularData};
GL::Texture2D specular;
specular.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGBA, Vector2i{1})
.setSubImage(0, {}, specularImage);
Shaders: add UBO support to all shaders.
5 years ago
PhongGL shader{PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::SpecularTexture|flag, 2};
Shaders: rendering tests for Phong shader.
7 years ago
if(data.multiBind)
shader.bindTextures(&ambient, &diffuse, &specular, nullptr);
else shader
.bindAmbientTexture(ambient)
.bindDiffuseTexture(diffuse)
.bindSpecularTexture(specular);
Shaders: add UBO support to all shaders.
5 years ago
if(flag == PhongGL::Flag{}) {
shader.setLightColors({0x993366_rgbf, 0x669933_rgbf})
.setLightPositions({{-3.0f, -3.0f, 2.0f, 0.0f},
{ 3.0f, -3.0f, 2.0f, 0.0f}})
.setTransformationMatrix(Matrix4::translation(Vector3::zAxis(-2.15f)))
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}
.setTransformationMatrix(Matrix4::translation(Vector3::zAxis(-2.15f)))
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
/* Has to be set because the default is black regardless of
whether the texture is present or not (it has no way to
know) */
.setAmbientColor(0xffffff_rgbf)
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}
.setPosition({-3.0f, -3.0f, 2.0f, 0.0f})
.setColor(0x993366_rgbf),
PhongLightUniform{}
.setPosition({ 3.0f, -3.0f, 2.0f, 0.0f})
.setColor(0x669933_rgbf)
}};
shader.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Phong 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 Phong shader.
7 years ago
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has some minor rounding differences (max = 1). ARM Mali G71
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
and Apple A8 has bigger rounding differences. */
const Float maxThreshold = 7.67f, meanThreshold = 0.100f;
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 15.34f, meanThreshold = 3.33f;
#endif
Shaders: rendering tests for Phong 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, "PhongTestFiles/colored.tga"),
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Phong shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag> void PhongGLTest::renderTextured() {
Shaders: rendering tests for Phong shader.
7 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 == PhongGL::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 Phong 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 Phong 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 Phong shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
PhongGL shader{data.flags|flag, 2};
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: rendering tests for Phong shader.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
GL::Texture2D ambient;
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 & PhongGL::Flag::AmbientTexture) {
Shaders: rendering tests for Phong shader.
7 years ago
Containers::Optional<Trade::ImageData2D> image;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/ambient-texture.tga")) && (image = importer->image2D(0)));
Shaders: rendering tests for Phong shader.
7 years ago
ambient.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
shader.bindAmbientTexture(ambient);
Shaders: rendering tests for Phong shader.
7 years ago
}
/* If no diffuse texture is present, dial down the default diffuse color
so ambient/specular is visible */
GL::Texture2D diffuse;
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 & PhongGL::Flag::DiffuseTexture) {
Shaders: rendering tests for Phong shader.
7 years ago
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 Phong shader.
7 years ago
diffuse.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
shader.bindDiffuseTexture(diffuse);
}
Shaders: rendering tests for Phong shader.
7 years ago
GL::Texture2D specular;
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 & PhongGL::Flag::SpecularTexture) {
Shaders: rendering tests for Phong shader.
7 years ago
Containers::Optional<Trade::ImageData2D> image;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/specular-texture.tga")) && (image = importer->image2D(0)));
Shaders: rendering tests for Phong shader.
7 years ago
specular.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
shader.bindSpecularTexture(specular);
}
if(flag == PhongGL::Flag{}) {
if(data.textureTransformation != Matrix3{})
shader.setTextureMatrix(data.textureTransformation);
if(data.flags & PhongGL::Flag::AmbientTexture)
/* Colorized. Case without a color (where it should be white) is
tested in renderSinglePixelTextured() */
shader.setAmbientColor(0xff9999_rgbf);
if(data.flags & PhongGL::Flag::DiffuseTexture)
/* Colorized. Case without a color (where it should be white) is
tested in renderSinglePixelTextured() */
shader.setDiffuseColor(0x9999ff_rgbf);
else shader.setDiffuseColor(0x333333_rgbf);
if(data.flags & PhongGL::Flag::SpecularTexture)
Shaders: rendering tests for Phong shader.
7 years ago
/* Colorized. Case without a color (where it should be white) is
tested in renderSinglePixelTextured() */
Shaders: add UBO support to all shaders.
5 years ago
shader.setSpecularColor(0x99ff99_rgbf);
/* Using default (white) light colors to have the texture data visible
better */
shader.setLightPositions({{-3.0f, -3.0f, 2.0f, 0.0f},
{ 3.0f, -3.0f, 2.0f, 0.0f}})
.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf))
.setNormalMatrix((Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix())
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
.draw(sphere);
Shaders: rendering tests for Phong shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
else if(flag == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)
)
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}.setNormalMatrix(
(Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix()
)
}};
GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, {
TextureTransformationUniform{}
.setTextureMatrix(data.textureTransformation)
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}.setPosition({-3.0f, -3.0f, 2.0f, 0.0f}),
PhongLightUniform{}.setPosition({3.0f, -3.0f, 2.0f, 0.0f})
}};
PhongMaterialUniform materialUniformData[1];
if(data.flags & PhongGL::Flag::AmbientTexture)
materialUniformData->setAmbientColor(0xff9999_rgbf);
if(data.flags & PhongGL::Flag::DiffuseTexture)
materialUniformData->setDiffuseColor(0x9999ff_rgbf);
else
materialUniformData->setDiffuseColor(0x333333_rgbf);
if(data.flags & PhongGL::Flag::SpecularTexture)
materialUniformData->setSpecularColor(0x99ff99_rgbf);
GL::Buffer materialUniform{materialUniformData};
if(data.textureTransformation != Matrix3{})
shader.bindTextureTransformationBuffer(textureTransformationUniform);
shader.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Phong shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has few rounding errors at the edges (giving a large max
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
error), but that's basically it. Apple A8 has more. */
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
const Float maxThreshold = 227.0f, meanThreshold = 0.202f;
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's a bit worse */
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
const Float maxThreshold = 227.0f, meanThreshold = 3.434f;
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#endif
Shaders: rendering tests for Phong 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, "PhongTestFiles", data.expected}),
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Phong shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag> void PhongGLTest::renderTexturedNormal() {
Shaders: rendering tests for Phong shader.
7 years ago
auto&& data = RenderTexturedNormalData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == PhongGL::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 Phong 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 Phong shader.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
/* Normal texture. Flip normal Y, if requested */
Shaders: rendering tests for Phong shader.
7 years ago
Containers::Optional<Trade::ImageData2D> image;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/normal-texture.tga")) && (image = importer->image2D(0)));
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
if(data.flipNormalY) for(auto row: image->mutablePixels<Color3ub>())
for(Color3ub& pixel: row)
pixel.y() = 255 - pixel.y();
GL::Texture2D normal;
Shaders: rendering tests for Phong shader.
7 years ago
normal.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
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
GL::Mesh plane = MeshTools::compile(Primitives::planeSolid( Primitives::PlaneFlag::TextureCoordinates));
Shaders: rendering tests for Phong shader.
7 years ago
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
/* Add tangents / bitangents of desired component count. Unused components
are set to zero to ensure the shader doesn't use them. */
const struct TangentBitangent {
Vector4 tangent;
Vector3 bitangent;
} tangentBitangent{data.tangent, data.bitangent};
Shaders: rendering tests for Phong shader.
7 years ago
GL::Buffer tangents;
Adapt to Corrade changes.
5 years ago
tangents.setData(Containers::Array<TangentBitangent>{DirectInit, 4, tangentBitangent});
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
plane.addVertexBuffer(tangents, 0, sizeof(TangentBitangent),
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
GL::DynamicAttribute{Shaders::PhongGL::Tangent4{data.tangentComponents}});
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
plane.addVertexBuffer(std::move(tangents), sizeof(Vector4),
sizeof(TangentBitangent),
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
GL::DynamicAttribute{Shaders::PhongGL::Bitangent{}});
Shaders: rendering tests for Phong shader.
7 years ago
/* Rotating the view a few times (together with light positions). If the
tangent transformation in the shader is correct, it should result in
exactly the same images. */
Shaders: add UBO support to all shaders.
5 years ago
PhongGL shader{PhongGL::Flag::NormalTexture|data.flags|flag, 2};
Shaders: test Phong normal texture multi-bind as well.
7 years ago
if(data.multiBind)
shader.bindTextures(nullptr, nullptr, nullptr, &normal);
else
shader.bindNormalTexture(normal);
Shaders: rendering tests for Phong shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
if(flag == PhongGL::Flag{}) {
/* Verify the default is working properly */
if(data.scale != 1.0f)
shader.setNormalTextureScale(data.scale);
shader.setLightPositions({
Matrix4::rotationZ(data.rotation)*Vector4{-3.0f, -3.0f, 2.0f, 0.0f},
Matrix4::rotationZ(data.rotation)*Vector4{ 3.0f, -3.0f, 2.0f, 0.0f}})
.setTransformationMatrix(Matrix4::translation(Vector3::zAxis(-2.35f))*
Matrix4::rotationZ(data.rotation)*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf))
.setNormalMatrix((Matrix4::rotationZ(data.rotation)*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix())
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
.setDiffuseColor(0x999999_rgbf)
.draw(plane);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)
)
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.35f))*
Matrix4::rotationZ(data.rotation)*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}.setNormalMatrix(
(Matrix4::rotationZ(data.rotation)*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix()
)
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
.setDiffuseColor(0x999999_rgbf)
.setNormalTextureScale(data.scale)
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}.setPosition(Matrix4::rotationZ(data.rotation)*Vector4{-3.0f, -3.0f, 2.0f, 0.0f}),
PhongLightUniform{}.setPosition(Matrix4::rotationZ(data.rotation)*Vector4{3.0f, -3.0f, 2.0f, 0.0f})
}};
shader.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.draw(plane);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Phong shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Image2D actual = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm});
Containers::StridedArrayView2D<Color3ub> pixels =
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<Color3ub>(actual.pixels<Color4ub>());
/* Rotate pixels back to upright position so we can compare with the 0°
file and ensure the tangent calculation is transformation invariant */
if(data.rotation == -90.0_degf)
pixels = pixels.flipped<0>().transposed<0, 1>();
else if(data.rotation == 90.0_degf)
pixels = pixels.flipped<1>().transposed<0, 1>();
else CORRADE_COMPARE(data.rotation, 0.0_degf);
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
Shaders: rendering tests for Phong shader.
7 years ago
/* One pixel in the center didn't survive the transformation. But that's
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
okay. Due to the density of the normal map, SwiftShader has an overally
Shaders: adapt Flat / Phong to more test results.
7 years ago
consistent off-by-a-bit error. AMD macOS drivers have one pixel off
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
due to a rounding error on the edge. Apple A8 has a slightly larger
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
overall difference; llvmpipe is off also. */
const Float maxThreshold = 191.0f, meanThreshold = 0.918f;
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
Shaders: adapt Flat / Phong to more test results.
7 years ago
const Float maxThreshold = 191.0f, meanThreshold = 3.017f;
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#endif
Shaders: rendering tests for Phong shader.
7 years ago
CORRADE_COMPARE_WITH(pixels,
Shaders: add a normal texture scale parameter to Phong. It's needed to support the new material attributes supported by glTF. The test output is slightly different as the normal coming from the texture wasn't normalized before.
6 years ago
Utility::Directory::join({_testDir, "PhongTestFiles", data.expected}),
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Phong shader.
7 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
template<class T, PhongGL::Flag flag> void PhongGLTest::renderVertexColor() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == PhongGL::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
Shaders: ambient also changes color with VertexColor in Phong. Also adapt the test to explicitly check for this.
7 years ago
/* Highlight the pole vertices and the middle rings */
Adapt to Corrade changes.
5 years ago
Containers::Array<T> colorData{DirectInit, sphereData.vertexCount(), 0x999999_rgbf};
Shaders: ambient also changes color with VertexColor in Phong. Also adapt the test to explicitly check for this.
7 years ago
for(std::size_t i = 0; i != 3*33 + 1; ++i)
colorData[sphereData.vertexCount() - i - 1] = 0xff0000_rgbf*5.0f;
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::PhongGL::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 diffuse;
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
diffuse.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
PhongGL shader{PhongGL::Flag::DiffuseTexture|PhongGL::Flag::VertexColor|flag, 2};
shader.bindDiffuseTexture(diffuse);
if(flag == PhongGL::Flag{}) {
shader
.setLightPositions({{-3.0f, -3.0f, 0.0f, 0.0f},
{ 3.0f, -3.0f, 0.0f, 0.0f}})
.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf))
.setNormalMatrix((Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix())
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
.setAmbientColor(0x111111_rgbf)
.setDiffuseColor(0x9999ff_rgbf)
.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)
)
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}.setNormalMatrix(
(Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix()
)
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}.setPosition({-3.0f, -3.0f, 0.0f, 0.0f}),
PhongLightUniform{}.setPosition({ 3.0f, -3.0f, 0.0f, 0.0f})
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
.setAmbientColor(0x111111_rgbf)
.setDiffuseColor(0x9999ff_rgbf)
}};
shader.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.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 a bit
more */
Shaders: ambient also changes color with VertexColor in Phong. Also adapt the test to explicitly check for this.
7 years ago
const Float maxThreshold = 115.4f, meanThreshold = 0.167f;
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: ambient also changes color with VertexColor in Phong. Also adapt the test to explicitly check for this.
7 years ago
const Float maxThreshold = 115.4f, meanThreshold = 3.254f;
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, "PhongTestFiles/vertexColor.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<PhongGL::Flag flag> void PhongGLTest::renderShininess() {
Shaders: rendering tests for Phong shader.
7 years ago
auto&& data = RenderShininessData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == PhongGL::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 Phong shader.
7 years ago
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32));
Shaders: add UBO support to all shaders.
5 years ago
PhongGL shader{flag};
if(flag == PhongGL::Flag{}) {
shader
.setLightPositions({{-3.0f, -3.0f, 2.0f, 0.0f}})
.setDiffuseColor(0xff3333_rgbf)
.setSpecularColor(data.specular)
.setShininess(data.shininess)
.setTransformationMatrix(Matrix4::translation(Vector3::zAxis(-2.15f)))
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
.draw(sphere);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)
)
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}.setPosition({-3.0f, -3.0f, 2.0f, 0.0f})
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
.setDiffuseColor(0xff3333_rgbf)
.setSpecularColor(data.specular)
.setShininess(data.shininess)
}};
shader
.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rendering tests for Phong 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 Phong shader.
7 years ago
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
{
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
#ifdef CORRADE_TARGET_IOS
/* Apple A8 has a large single-pixel difference in the shininess ~= 0
case, but it's not nearly as bad as in the "huge ring" case on Mesa
etc. */
const Float maxThreshold = 211.0f, meanThreshold = 0.052f;
#elif !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
/* SwiftShader has some minor rounding differences (max = 1.67). ARM
Mali G71 has bigger rounding differences. */
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
const Float maxThreshold = 221.0f, meanThreshold = 0.106f;
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 16.667f, meanThreshold = 2.583f;
#endif
#if defined(MAGNUM_TARGET_GLES) && !defined(MAGNUM_TARGET_WEBGL)
CORRADE_EXPECT_FAIL_IF(data.shininess <= 0.0011f && (GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::SwiftShader),
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
"SwiftShader has a much larger ring for the overflown shininess.");
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#endif
#if defined(CORRADE_TARGET_ANDROID) && defined(MAGNUM_TARGET_GLES2)
CORRADE_EXPECT_FAIL_IF(data.shininess == 0.0f && (GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::ArmMali),
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
"ARM Mali has a much larger ring for the overflown shininess when it's exactly 0.");
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#endif
Shaders: adapt Flat / Phong to more test results.
7 years ago
#ifndef MAGNUM_TARGET_WEBGL
GL: rework Context to not use any STL containers. We're going to eventually include this class in all Application classes (need that in order to inherit a to-be-created Configuration class) and the <string> and <vector> would be just too much. This change caused magnum-gl-info.wasm (WebGL 2 build) to go down from 247 to 245 kB. Not much, but that's I guess because there's still a lot other vectors of strings elsewhere. There's a lot more places to clean up, will do those in separate commits. This change is the most atomic I could do, and it introduces a breaking change to all APIs that returned a std::vector or a std::string. Fortunately (or as I hope) those weren't used that much, so it shouldn't cause build breakages for that many people. Quite a lot of the optimization ideas is borrowed from the new Vk library -- such as "interning" the driver workaround strings to avoid allocating their copies.
5 years ago
CORRADE_EXPECT_FAIL_IF(data.shininess == 0.0f && (GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::Mesa) && GL::Context::current().rendererString().contains("AMD"),
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
"AMD Mesa drivers have a much larger ring for the overflown shininess when it's exactly 0.");
GL: rework Context to not use any STL containers. We're going to eventually include this class in all Application classes (need that in order to inherit a to-be-created Configuration class) and the <string> and <vector> would be just too much. This change caused magnum-gl-info.wasm (WebGL 2 build) to go down from 247 to 245 kB. Not much, but that's I guess because there's still a lot other vectors of strings elsewhere. There's a lot more places to clean up, will do those in separate commits. This change is the most atomic I could do, and it introduces a breaking change to all APIs that returned a std::vector or a std::string. Fortunately (or as I hope) those weren't used that much, so it shouldn't cause build breakages for that many people. Quite a lot of the optimization ideas is borrowed from the new Vk library -- such as "interning" the driver workaround strings to avoid allocating their copies.
5 years ago
CORRADE_EXPECT_FAIL_IF(data.shininess <= 0.0011f && (GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::Mesa) && GL::Context::current().rendererString().contains("llvmpipe"),
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
"Mesa llvmpipe drivers have a much larger ring for the overflown shininess.");
Shaders: adapt Flat / Phong to more test results.
7 years ago
#endif
#if defined(CORRADE_TARGET_APPLE) && !defined(CORRADE_TARGET_IOS)
GL: rework Context to not use any STL containers. We're going to eventually include this class in all Application classes (need that in order to inherit a to-be-created Configuration class) and the <string> and <vector> would be just too much. This change caused magnum-gl-info.wasm (WebGL 2 build) to go down from 247 to 245 kB. Not much, but that's I guess because there's still a lot other vectors of strings elsewhere. There's a lot more places to clean up, will do those in separate commits. This change is the most atomic I could do, and it introduces a breaking change to all APIs that returned a std::vector or a std::string. Fortunately (or as I hope) those weren't used that much, so it shouldn't cause build breakages for that many people. Quite a lot of the optimization ideas is borrowed from the new Vk library -- such as "interning" the driver workaround strings to avoid allocating their copies.
5 years ago
CORRADE_EXPECT_FAIL_IF(data.shininess == 0.0f && GL::Context::current().rendererString().contains("AMD"),
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
"AMD on macOS has a much larger ring for the overflown shininess when it's exactly 0.");
Shaders: adapt Flat / Phong to more test results.
7 years ago
#endif
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
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, "PhongTestFiles", data.expected}),
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
}
/* Test the special overflow results as well */
Shaders: adapt Flat / Phong to more test results.
7 years ago
if(false
#if defined(MAGNUM_TARGET_GLES) && !defined(MAGNUM_TARGET_WEBGL)
|| (data.shininess <= 0.0011f && (GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::SwiftShader))
#endif
#ifndef MAGNUM_TARGET_WEBGL
GL: rework Context to not use any STL containers. We're going to eventually include this class in all Application classes (need that in order to inherit a to-be-created Configuration class) and the <string> and <vector> would be just too much. This change caused magnum-gl-info.wasm (WebGL 2 build) to go down from 247 to 245 kB. Not much, but that's I guess because there's still a lot other vectors of strings elsewhere. There's a lot more places to clean up, will do those in separate commits. This change is the most atomic I could do, and it introduces a breaking change to all APIs that returned a std::vector or a std::string. Fortunately (or as I hope) those weren't used that much, so it shouldn't cause build breakages for that many people. Quite a lot of the optimization ideas is borrowed from the new Vk library -- such as "interning" the driver workaround strings to avoid allocating their copies.
5 years ago
|| (data.shininess == 0.0f && (GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::Mesa) && GL::Context::current().rendererString().contains("AMD"))
Shaders: adapt Flat / Phong to more test results.
7 years ago
#endif
#if defined(CORRADE_TARGET_APPLE) && !defined(CORRADE_TARGET_IOS)
GL: rework Context to not use any STL containers. We're going to eventually include this class in all Application classes (need that in order to inherit a to-be-created Configuration class) and the <string> and <vector> would be just too much. This change caused magnum-gl-info.wasm (WebGL 2 build) to go down from 247 to 245 kB. Not much, but that's I guess because there's still a lot other vectors of strings elsewhere. There's a lot more places to clean up, will do those in separate commits. This change is the most atomic I could do, and it introduces a breaking change to all APIs that returned a std::vector or a std::string. Fortunately (or as I hope) those weren't used that much, so it shouldn't cause build breakages for that many people. Quite a lot of the optimization ideas is borrowed from the new Vk library -- such as "interning" the driver workaround strings to avoid allocating their copies.
5 years ago
|| (data.shininess == 0.0f && GL::Context::current().rendererString().contains("AMD"))
Shaders: adapt Flat / Phong to more test results.
7 years ago
#endif
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#if defined(CORRADE_TARGET_ANDROID) && defined(MAGNUM_TARGET_GLES2)
|| (data.shininess == 0.0f && (GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::ArmMali))
#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, "PhongTestFiles", "shininess0-overflow.tga"}),
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
/* The threshold = 0.001 case has a slight reddish tone on
SwiftShader; ARM Mali has one pixel off */
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
(DebugTools::CompareImageToFile{_manager, 255.0f, 23.1f}));
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
}
Shaders: rendering tests for Phong shader.
7 years ago
}
void PhongGLTest::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 PhongGLTest::renderAlphaTeardown() {
if(RenderAlphaData[testCaseInstanceId()].blending)
GL::Renderer::disable(GL::Renderer::Feature::Blending);
renderTeardown();
}
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag> void PhongGLTest::renderAlpha() {
Shaders: rendering tests for Phong 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 == PhongGL::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 Phong 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 Phong shader.
7 years ago
Containers::Optional<Trade::ImageData2D> image;
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
GL::Texture2D ambient;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join({_testDir, "TestFiles", data.ambientTexture})) && (image = importer->image2D(0)));
Shaders: rendering tests for Phong shader.
7 years ago
ambient.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGBA, image->size())
.setSubImage(0, {}, *image);
GL::Texture2D diffuse;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join({_testDir, "TestFiles", data.diffuseTexture})) && (image = importer->image2D(0)));
Shaders: rendering tests for Phong shader.
7 years ago
diffuse.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge);
/* In some instances the diffuse texture is just three-component, handle
that properly */
if(image->format() == PixelFormat::RGBA8Unorm)
diffuse.setStorage(1, TextureFormatRGBA, image->size());
else {
CORRADE_COMPARE(image->format(), PixelFormat::RGB8Unorm);
diffuse.setStorage(1, TextureFormatRGB, image->size());
}
diffuse.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 Phong shader.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
PhongGL shader{data.flags|flag, 2};
shader.bindTextures(&ambient, &diffuse, nullptr, nullptr);
if(flag == PhongGL::Flag{}) {
shader.setLightPositions({{-3.0f, -3.0f, 2.0f, 0.0f},
{ 3.0f, -3.0f, 2.0f, 0.0f}})
.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf))
.setNormalMatrix((Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix())
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
.setAmbientColor(data.ambientColor)
.setDiffuseColor(data.diffuseColor)
.setSpecularColor(0xffffff00_rgbaf);
/* Test that the default is correct by not setting the threshold if
it's equal to the default */
if(data.flags & PhongGL::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 == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)
)
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}.setNormalMatrix(
(Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix()
)
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}.setPosition({-3.0f, -3.0f, 2.0f, 0.0f}),
PhongLightUniform{}.setPosition({3.0f, -3.0f, 2.0f, 0.0f})
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
.setAmbientColor(data.ambientColor)
.setDiffuseColor(data.diffuseColor)
.setSpecularColor(0xffffff00_rgbaf)
.setAlphaMask(data.threshold)
}};
shader.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform);
/* 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 Phong shader.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
Shaders: rendering tests for Phong shader.
7 years ago
/* In some cases (separate vs combined alpha) there are off-by-one errors.
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
That's okay, as we have only 8bit texture precision. SwiftShader has
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
additionally a few minor rounding errors at the edges, Apple A8 a bit
more. */
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
const Float maxThreshold = 189.4f, meanThreshold = 0.385f;
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
const Float maxThreshold = 189.4f, meanThreshold = 4.736f;
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
#endif
Shaders: rendering tests for Phong 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.expected),
Shaders: inflate fuzzy thresholds for PhongGLTest, add some XFAILs. Tested on WebGL 1 and 2, SwiftShader ES2 and ES3 and ARM Mali ES2 and ES3 now, all pass. SwiftShader has a bit different output for zero shininess, but that's a corner case so I'm not going to investigate further, just adding the expected wrong output to check against as well.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rendering tests for Phong shader.
7 years ago
}
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
void PhongGLTest::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
{PhongGL::ColorOutput, GL::Framebuffer::ColorAttachment{0}},
{PhongGL::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 PhongGLTest::renderObjectIdTeardown() {
_color = GL::Renderbuffer{NoCreate};
_objectId = GL::Renderbuffer{NoCreate};
_framebuffer = GL::Framebuffer{NoCreate};
}
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag> void PhongGLTest::renderObjectId() {
#ifndef MAGNUM_TARGET_GLES2
if(flag == PhongGL::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
PhongGL shader{PhongGL::Flag::ObjectId|flag, 2};
Shaders: add UBO support to all shaders.
5 years ago
if(flag == PhongGL::Flag{}) {
shader
.setLightColors({0x993366_rgbf, 0x669933_rgbf})
.setLightPositions({{-3.0f, -3.0f, 2.0f, 0.0f},
{ 3.0f, -3.0f, 2.0f, 0.0f}})
.setAmbientColor(0x330033_rgbf)
.setDiffuseColor(0xccffcc_rgbf)
.setSpecularColor(0x6666ff_rgbf)
.setTransformationMatrix(Matrix4::translation(Vector3::zAxis(-2.15f)))
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
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 == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)
)
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
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
PhongDrawUniform{}
.setObjectId(48526)
Shaders: add UBO support to all shaders.
5 years ago
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}
.setPosition({-3.0f, -3.0f, 2.0f, 0.0f})
.setColor(0x993366_rgbf),
PhongLightUniform{}
.setPosition({3.0f, -3.0f, 2.0f, 0.0f})
.setColor(0x669933_rgbf)
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
.setAmbientColor(0x330033_rgbf)
.setDiffuseColor(0xccffcc_rgbf)
.setSpecularColor(0x6666ff_rgbf)
}};
shader.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.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 colored() */
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* SwiftShader has some minor rounding differences (max = 1). ARM Mali G71
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
and Apple A8 has bigger rounding differences. */
const Float maxThreshold = 8.34f, meanThreshold = 0.100f;
Shaders: support object ID output in Flat and Phong.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 15.34f, meanThreshold = 3.33f;
#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, "PhongTestFiles/colored.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<PhongGL::Flag flag> void PhongGLTest::renderLights() {
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
auto&& data = RenderLightsData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == PhongGL::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: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
GL::Mesh plane = MeshTools::compile(Primitives::planeSolid());
Matrix4 transformation =
Matrix4::translation({0.0f, 0.0f, -1.5f});
Shaders: add UBO support to all shaders.
5 years ago
PhongGL shader{flag, 1};
if(flag == PhongGL::Flag{}) {
shader
/* Set non-black ambient to catch accidental NaNs -- the render
should never be fully black */
.setAmbientColor(0x222222_rgbf)
.setSpecularColor(data.specularColor)
.setLightPositions({data.position})
.setLightColors({0xff8080_rgbf*data.intensity})
.setLightSpecularColors({data.lightSpecularColor})
.setLightRanges({data.range})
.setShininess(60.0f)
.setTransformationMatrix(transformation)
.setNormalMatrix(transformation.normalMatrix())
.setProjectionMatrix(Matrix4::perspectiveProjection(80.0_degf, 1.0f, 0.1f, 20.0f))
.draw(plane);
}
#ifndef MAGNUM_TARGET_GLES2
else if(flag == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(80.0_degf, 1.0f, 0.1f, 20.0f)
)
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}.setTransformationMatrix(transformation)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}.setNormalMatrix(transformation.normalMatrix())
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}
.setPosition({data.position})
.setColor(0xff8080_rgbf*data.intensity)
.setSpecularColor(data.lightSpecularColor)
.setRange(data.range),
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
.setAmbientColor(0x222222_rgbf)
.setSpecularColor(data.specularColor)
.setShininess(60.0f)
}};
shader
.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.draw(plane);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
const Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm});
/* Analytical output check. Comment this out when image comparison fails
for easier debugging. */
for(const auto& pick: data.picks) {
CORRADE_ITERATION(pick.first);
CORRADE_COMPARE_WITH(
image.pixels<Color4ub>()[pick.first.y()][pick.first.x()].xyz(),
pick.second, TestSuite::Compare::around(0x010101_rgb));
}
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: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
const Float maxThreshold = 3.0f, meanThreshold = 0.02f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 3.0f, meanThreshold = 0.02f;
#endif
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<const Color3ub>(image.pixels<Color4ub>()),
Utility::Directory::join({_testDir, "PhongTestFiles", data.file}),
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: properly test Phong one-by-one light property setters. Testing that they don't assert *isn't* enough.
6 years ago
}
void PhongGLTest::renderLightsSetOneByOne() {
GL::Mesh plane = MeshTools::compile(Primitives::planeSolid());
Matrix4 transformation =
Matrix4::translation({0.0f, 0.0f, -1.5f});
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
PhongGL{{}, 2}
Shaders: properly test Phong one-by-one light property setters. Testing that they don't assert *isn't* enough.
6 years ago
/* Set non-black ambient to catch accidental NaNs -- the render should
never be fully black */
.setAmbientColor(0x222222_rgbf)
/* First light is directional, from back, so it shouldn't affect the
output at all -- we only want to test that the ID is used properly */
.setLightPosition(0, {-1.0f, 1.5f, -0.5f, 0.0f})
Shaders: fix distance attentuation calculation in Phong. Not that either way would be more correct than the other (this is what three.js uses I think), but it was documented everywhere to be 1/(1 + d^2) but the calculation instead did 1/(1 + d)^2 This now also means the analytical test equation works. I should have paid more attention to it not matching before, because that obviously pointed to this problem. Point lights are now significantly brighter than before, the tests were updated to use a larger distance to avoid issues with overflows. Does not affect the (default) directional lights in any way.
6 years ago
.setLightPosition(1, {0.75f, -0.75f, -0.75f, 1.0f})
Shaders: properly test Phong one-by-one light property setters. Testing that they don't assert *isn't* enough.
6 years ago
.setLightColor(0, 0x00ffff_rgbf)
.setLightColor(1, 0xff8080_rgbf)
Shaders: add an ability to control specular light color to Phong.
6 years ago
.setLightSpecularColor(0, 0x0000ff_rgbf)
.setLightSpecularColor(1, 0x80ff80_rgbf)
Shaders: properly test Phong one-by-one light property setters. Testing that they don't assert *isn't* enough.
6 years ago
.setLightRange(0, Constants::inf())
.setLightRange(1, 1.5f)
.setShininess(60.0f)
.setTransformationMatrix(transformation)
.setNormalMatrix(transformation.normalMatrix())
.setProjectionMatrix(Matrix4::perspectiveProjection(80.0_degf, 1.0f, 0.1f, 20.0f))
.draw(plane);
MAGNUM_VERIFY_NO_GL_ERROR();
const Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::RGBA8Unorm});
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: properly test Phong one-by-one light property setters. Testing that they don't assert *isn't* enough.
6 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
const Float maxThreshold = 3.0f, meanThreshold = 0.02f;
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 3.0f, meanThreshold = 0.02f;
#endif
CORRADE_COMPARE_WITH(
/* Dropping the alpha channel, as it's always 1.0 */
Containers::arrayCast<const Color3ub>(image.pixels<Color4ub>()),
Utility::Directory::join({_testDir, "PhongTestFiles/light-point-range1.5.tga"}),
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
}
Shaders: repro case for a bug in Phong light direction calculation. Interestingly enough / sadly none of the tests showed a clear difference when removing the incorrect normalization, so here's a dedicated test case. Sigh.
6 years ago
void PhongGLTest::renderLowLightAngle() {
GL::Mesh plane = MeshTools::compile(Primitives::planeSolid());
Matrix4 transformation =
Matrix4::translation({0.0f, 0.0f, -2.0f})*
Matrix4::rotationX(-75.0_degf)*
Matrix4::scaling(Vector3::yScale(10.0f));
/* The light position is at the camera location, so the most light should
be there and not at some other place. This is a repro case for a bug
where lightDirection = normalize(lightPosition - transformedPosition)
in the vertex shader, where the incorrect normalization caused the
fragment-interpolated light direction being incorrect, most visible with
long polygons and low light angles. */
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
PhongGL{{}, 1}
Shaders: rework Phong to support directional and attenuated point lights. This is a -- long overdue -- breaking change to the rendering output of this shader, finally adding support for lights that get darker over distance. The attenuation equation is basically what's documented in LightData, and the distinction between directional and point lights is made using a newly added the fourth component of position (which means the old three-component setters are all deprecated). This allows the shader code to be practically branchless, which I find to be nice. This breaks basically all rendering output so all existing Phong and MeshTools::compile() test outputs had to be regenerated.
6 years ago
.setLightPositions({{0.0f, 0.1f, 0.0f, 1.0f}})
Shaders: repro case for a bug in Phong light direction calculation. Interestingly enough / sadly none of the tests showed a clear difference when removing the incorrect normalization, so here's a dedicated test case. Sigh.
6 years ago
.setShininess(200)
.setTransformationMatrix(transformation)
.setNormalMatrix(transformation.normalMatrix())
.setProjectionMatrix(Matrix4::perspectiveProjection(80.0_degf, 1.0f, 0.1f, 20.0f))
.draw(plane);
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: repro case for a bug in Phong light direction calculation. Interestingly enough / sadly none of the tests showed a clear difference when removing the incorrect normalization, so here's a dedicated test case. Sigh.
6 years ago
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
MeshTools, Shaders: adapt thresholds for SwiftShader. The Phong bugfix causes some rounding errors to be larger than before.
6 years ago
const Float maxThreshold = 63.0f, meanThreshold = 0.36f;
Shaders: repro case for a bug in Phong light direction calculation. Interestingly enough / sadly none of the tests showed a clear difference when removing the incorrect normalization, so here's a dedicated test case. Sigh.
6 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
MeshTools, Shaders: adapt thresholds for SwiftShader. The Phong bugfix causes some rounding errors to be larger than before.
6 years ago
const Float maxThreshold = 63.0f, meanThreshold = 0.36f;
Shaders: repro case for a bug in Phong light direction calculation. Interestingly enough / sadly none of the tests showed a clear difference when removing the incorrect normalization, so here's a dedicated test case. Sigh.
6 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>()),
Utility::Directory::join(_testDir, "PhongTestFiles/low-light-angle.tga"),
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
}
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag> void PhongGLTest::renderZeroLights() {
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
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: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flag == PhongGL::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: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
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: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 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
/* Enable also Object ID, if supported */
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
PhongGL::Flags flags = PhongGL::Flag::AmbientTexture|PhongGL::Flag::NormalTexture|PhongGL::Flag::AlphaMask;
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_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#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
flags |= PhongGL::Flag::ObjectId;
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: add UBO support to all shaders.
5 years ago
PhongGL shader{flags|flag, 0};
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer = _manager.loadAndInstantiate("AnyImageImporter");
CORRADE_VERIFY(importer);
GL::Texture2D ambient;
Containers::Optional<Trade::ImageData2D> ambientImage;
Fixed shaders tests for iOS
7 years ago
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/diffuse-alpha-texture.tga")) && (ambientImage = importer->image2D(0)));
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
ambient.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGBA, ambientImage->size())
.setSubImage(0, {}, *ambientImage);
Shaders: add UBO support to all shaders.
5 years ago
shader.bindAmbientTexture(ambient);
if(flag == PhongGL::Flag{}) {
shader
.setAmbientColor(0x9999ff_rgbf)
.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf))
.setProjectionMatrix(Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
/* Keep alpha mask at the default 0.5 to test the default */
/* Passing a zero-sized light position / color array, shouldn't
assert */
.setLightPositions(Containers::ArrayView<const Vector4>{})
.setLightColors(Containers::ArrayView<const Color3>{})
/* Using a bogus normal matrix -- it's not used so it should be
okay. Same for all other unused values, they should get
ignored. */
.setNormalMatrix(Matrix3x3{Math::ZeroInit})
.setDiffuseColor(0xfa9922_rgbf)
.setSpecularColor(0xfa9922_rgbf)
.setShininess(0.2f)
.setNormalTextureScale(-0.3f);
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
shader.setObjectId(65534);
}
#endif
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
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);
}
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_GLES2
Shaders: add UBO support to all shaders.
5 years ago
else if(flag == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)
)
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
PhongDrawUniform{}
/* Using a bogus normal matrix -- it's not used so it should be
okay. */
.setNormalMatrix(Matrix3x3{Math::ZeroInit})
.setObjectId(65534)
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
.setAmbientColor(0x9999ff_rgbf)
/* Same for all other unused values, they should get ignored */
.setDiffuseColor(0xfa9922_rgbf)
.setSpecularColor(0xfa9922_rgbf)
.setShininess(0.2f)
.setNormalTextureScale(-0.3f)
}};
/* Not binding any light buffer as it's not needed */
shader.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform);
/* 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);
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: add UBO support to all shaders.
5 years ago
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
/* Compared to FlatGLTest::renderAlpha3D(0.5), there's a bit more different
pixels on the edges, caused by matrix multiplication being done in the
Shaders: inflate rendering test thresholds a bit for the iPhone GPU.
7 years ago
shader and not on the CPU side. Apple A8 sprinkles a bunch of tiny
differences here and there. */
MeshTools,Shaders: make the rendering tests pass on llvmpipe.
6 years ago
const Float maxThreshold = 139.0f, meanThreshold = 0.421f;
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
#else
/* WebGL 1 doesn't have 8bit renderbuffer storage, so it's way worse */
const Float maxThreshold = 139.0f, meanThreshold = 2.896f;
#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>()),
/* Should be equivalent to masked Flat3D */
Fixed shaders tests for iOS
7 years ago
Utility::Directory::join(_testDir, "FlatTestFiles/textured3D-alpha-mask0.5.tga"),
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
(DebugTools::CompareImageToFile{_manager, maxThreshold, meanThreshold}));
#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). */
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>())
#endif
{
_framebuffer.mapForRead(GL::Framebuffer::ColorAttachment{1});
CORRADE_COMPARE(_framebuffer.checkStatus(GL::FramebufferTarget::Read), GL::Framebuffer::Status::Complete);
Image2D image = _framebuffer.read(_framebuffer.viewport(), {PixelFormat::R32UI});
MAGNUM_VERIFY_NO_GL_ERROR();
/* Outside of the object, cleared to 27 */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[10][10], 27);
/* Inside of the object. Verify that it can hold 16 bits at least. */
CORRADE_COMPARE(image.pixels<UnsignedInt>()[40][46], 65534);
}
Shaders: allow Phong with zero lights. Which makes it equivalent to Flat3D. Useful to reduce complexity in apps that render models with pre-baked lighting.
7 years ago
#endif
}
Shaders: add UBO support to all shaders.
5 years ago
template<PhongGL::Flag flag> void PhongGLTest::renderInstanced() {
Shaders: implement instancing in Phong.
6 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 == PhongGL::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 Phong.
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 Phong.
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 Phong.
6 years ago
#endif
#endif
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: implement instancing in Phong.
6 years ago
GL::Mesh sphere = MeshTools::compile(Primitives::uvSphereSolid(16, 32,
Primitives::UVSphereFlag::TextureCoordinates|
Primitives::UVSphereFlag::Tangents));
/* Three spheres, each in a different location, differently rotated to
ensure the normal matrix is properly used as well. */
struct {
Matrix4 transformation;
Matrix3x3 normal;
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 Phong.
6 years ago
} instanceData[] {
{Matrix4::translation({-1.25f, -1.25f, 0.0f})*
Matrix4::rotationX(90.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
{}, 0xff3333_rgbf, {0.0f, 0.0f}, 211},
Shaders: implement instancing in Phong.
6 years ago
{Matrix4::translation({ 1.25f, -1.25f, 0.0f})*
Matrix4::rotationY(90.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
{}, 0x33ff33_rgbf, {1.0f, 0.0f}, 4627},
Shaders: implement instancing in Phong.
6 years ago
{Matrix4::translation({ 0.0f, 1.0f, 1.0f})*
Matrix4::rotationZ(90.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
{}, 0x9999ff_rgbf, {0.5f, 1.0f}, 35363}
Shaders: implement instancing in Phong.
6 years ago
};
for(auto& instance: instanceData)
instance.normal = instance.transformation.normalMatrix();
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
PhongGL::TransformationMatrix{},
PhongGL::NormalMatrix{},
PhongGL::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
PhongGL::TextureOffset{},
#ifndef MAGNUM_TARGET_GLES2
PhongGL::ObjectId{}
#else
4
#endif
)
Shaders: implement instancing in Phong.
6 years ago
.setInstanceCount(3);
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)));
GL::Texture2D diffuse;
diffuse.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
CORRADE_VERIFY(importer->openFile(Utility::Directory::join(_testDir, "TestFiles/normal-texture.tga")) && (image = importer->image2D(0)));
GL::Texture2D normal;
normal.setMinificationFilter(GL::SamplerFilter::Linear)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setStorage(1, TextureFormatRGB, image->size())
.setSubImage(0, {}, *image);
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 */
PhongGL::Flags flags = PhongGL::Flag::DiffuseTexture|
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
PhongGL::Flag::VertexColor|
PhongGL::Flag::InstancedTransformation|
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
PhongGL::Flag::InstancedTextureOffset|data.flags|flag;
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_GLES
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::gpu_shader4>())
#endif
{
flags |= PhongGL::Flag::InstancedObjectId;
}
#endif
PhongGL shader{flags, 2};
Shaders: add UBO support to all shaders.
5 years ago
shader.bindDiffuseTexture(diffuse);
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 & PhongGL::Flag::NormalTexture)
Shaders: implement instancing in Phong.
6 years ago
shader.bindNormalTexture(normal);
Shaders: add UBO support to all shaders.
5 years ago
if(flag == PhongGL::Flag{}) {
shader
.setLightPositions({{-3.0f, -3.0f, 2.0f, 0.0f},
{ 3.0f, -3.0f, 2.0f, 0.0f}})
.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-1.75f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)*
Matrix4::scaling(Vector3{0.4f}))
.setNormalMatrix((Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix())
.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f))
.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
.setDiffuseColor(0xffff99_rgbf);
#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 == PhongGL::Flag::UniformBuffers) {
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)
)
}};
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, {
TransformationUniform3D{}.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-1.75f))*
Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)*
Matrix4::scaling(Vector3{0.4f})
)
}};
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, {
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
PhongDrawUniform{}
.setNormalMatrix(
(Matrix4::rotationY(-15.0_degf)*
Matrix4::rotationX(15.0_degf)).normalMatrix())
.setObjectId(1000) /* gets added to the per-instance ID */
Shaders: add UBO support to all shaders.
5 years ago
}};
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, {
PhongMaterialUniform{}
.setDiffuseColor(0xffff99_rgbf)
}};
GL::Buffer textureTransformationUniform{GL::Buffer::TargetHint::Uniform, {
TextureTransformationUniform{}
.setTextureMatrix(Matrix3::scaling(Vector2{0.5f}))
}};
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, {
PhongLightUniform{}.setPosition(Vector4{-3.0f, -3.0f, 2.0f, 0.0f}),
PhongLightUniform{}.setPosition(Vector4{3.0f, -3.0f, 2.0f, 0.0f})
}};
shader.bindProjectionBuffer(projectionUniform)
.bindTransformationBuffer(transformationUniform)
.bindTextureTransformationBuffer(textureTransformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform)
.draw(sphere);
}
#endif
else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Shaders: implement instancing in Phong.
6 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
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, "PhongTestFiles", data.file}),
(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 Phong.
6 years ago
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
void PhongGLTest::renderMulti() {
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 >= PhongGL::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 diffuse;
if(data.flags & PhongGL::Flag::DiffuseTexture) {
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)));
diffuse.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|
Primitives::UVSphereFlag::Tangents);
/* Plane is a strip, make it indexed first */
Trade::MeshData planeData = MeshTools::generateIndices(Primitives::planeSolid(
Primitives::PlaneFlag::TextureCoordinates|
Primitives::PlaneFlag::Tangents));
Trade::MeshData coneData = Primitives::coneSolid(1, 32, 1.0f,
Primitives::ConeFlag::TextureCoordinates|
Primitives::ConeFlag::Tangents);
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());
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
Matrix4::perspectiveProjection(60.0_degf, 1.0f, 0.1f, 10.0f)
)
}};
/* 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. */
Containers::Array<PhongMaterialUniform> materialData{data.uniformIncrement + 1};
materialData[0*data.uniformIncrement] = PhongMaterialUniform{}
.setDiffuseColor(data.flags & PhongGL::Flag::DiffuseTexture ?
0xffffff_rgbf : 0x00ffff_rgbf);
materialData[1*data.uniformIncrement] = PhongMaterialUniform{}
.setDiffuseColor(data.flags & PhongGL::Flag::DiffuseTexture ?
0xffffff_rgbf : 0xffff00_rgbf);
GL::Buffer materialUniform{GL::Buffer::TargetHint::Uniform, materialData};
/* The shader has two lights hardcoded, so make sure the buffer can fit
2 items enough even though the last draw needs just one light. Not a
problem on desktop, but WebGL complains. */
Containers::Array<PhongLightUniform> lightData{2*data.uniformIncrement + 2};
lightData[0*data.uniformIncrement] = PhongLightUniform{}
.setPosition(Vector4{0.0f, 0.0f, 1.0f, 0.0f})
.setColor(data.flags & PhongGL::Flag::DiffuseTexture ?
0xffffff_rgbf : 0x00ffff_rgbf);
lightData[1*data.uniformIncrement + 0] = PhongLightUniform{}
.setPosition(Vector4{-3.0f, -3.0f, 2.0f, 0.0f})
.setColor(0x999999_rgbf)
.setSpecularColor(0xff0000_rgbf);
lightData[1*data.uniformIncrement + 1] = PhongLightUniform{}
.setPosition(Vector4{3.0f, -3.0f, 2.0f, 0.0f})
.setColor(0x999999_rgbf)
.setSpecularColor(0x00ff00_rgbf);
/* This will put the light to position 4 in case data.uniformIncrement is 1
and to an offset aligned to 256 if it's higher */
lightData[2*data.uniformIncrement + 1/data.uniformIncrement] = PhongLightUniform{}
.setPosition(Vector4{0.0f, 0.0f, 1.0f, 0.0f})
.setColor(data.flags & PhongGL::Flag::DiffuseTexture ?
0xffffff_rgbf : 0xff00ff_rgbf);
GL::Buffer lightUniform{GL::Buffer::TargetHint::Uniform, lightData};
Containers::Array<TransformationUniform3D> transformationData{2*data.uniformIncrement + 1};
transformationData[0*data.uniformIncrement] = TransformationUniform3D{}
.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::scaling(Vector3{0.4f})*
Matrix4::translation({-1.25f, -1.25f, 0.0f})*
/* to test the normal matrix is applied properly */
Matrix4::rotationX(90.0_degf)
);
transformationData[1*data.uniformIncrement] = TransformationUniform3D{}
.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::scaling(Vector3{0.4f})*
Matrix4::translation({ 1.25f, -1.25f, 0.0f})
);
transformationData[2*data.uniformIncrement] = TransformationUniform3D{}
.setTransformationMatrix(
Matrix4::translation(Vector3::zAxis(-2.15f))*
Matrix4::scaling(Vector3{0.4f})*
Matrix4::translation({ 0.0f, 1.0f, 1.0f})
);
GL::Buffer transformationUniform{GL::Buffer::TargetHint::Uniform, transformationData};
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<PhongDrawUniform> drawData{2*data.uniformIncrement + 1};
/* Material / light offsets are zero if we have single draw, as those are
done with UBO offset bindings instead. */
drawData[0*data.uniformIncrement] = PhongDrawUniform{}
.setMaterialId(data.drawCount == 1 ? 0 : 1)
.setLightOffsetCount(data.drawCount == 1 ? 0 : 1, 2)
.setNormalMatrix(transformationData[0*data.uniformIncrement].transformationMatrix.normalMatrix())
.setObjectId(1211);
drawData[1*data.uniformIncrement] = PhongDrawUniform{}
.setMaterialId(data.drawCount == 1 ? 0 : 0)
.setLightOffsetCount(data.drawCount == 1 ? 0 : 3, 1)
.setNormalMatrix(transformationData[1*data.uniformIncrement].transformationMatrix.normalMatrix())
.setObjectId(5627);
drawData[2*data.uniformIncrement] = PhongDrawUniform{}
.setMaterialId(data.drawCount == 1 ? 0 : 1)
.setLightOffsetCount(data.drawCount == 1 ? 0 : 0, 1)
.setNormalMatrix(transformationData[2*data.uniformIncrement].transformationMatrix.normalMatrix())
.setObjectId(36363);
GL::Buffer drawUniform{GL::Buffer::TargetHint::Uniform, drawData};
PhongGL shader{PhongGL::Flag::UniformBuffers|PhongGL::Flag::ObjectId|data.flags, data.lightCount, data.materialCount, data.drawCount};
shader.bindProjectionBuffer(projectionUniform);
if(data.flags & PhongGL::Flag::DiffuseTexture)
shader.bindDiffuseTexture(diffuse);
/* Just one draw, rebinding UBOs each time */
if(data.drawCount == 1) {
shader.bindMaterialBuffer(materialUniform,
1*data.uniformIncrement*sizeof(PhongMaterialUniform),
sizeof(PhongMaterialUniform));
shader.bindLightBuffer(lightUniform,
1*data.uniformIncrement*sizeof(PhongLightUniform),
2*sizeof(PhongLightUniform));
shader.bindTransformationBuffer(transformationUniform,
0*data.uniformIncrement*sizeof(TransformationUniform3D),
sizeof(TransformationUniform3D));
shader.bindDrawBuffer(drawUniform,
0*data.uniformIncrement*sizeof(PhongDrawUniform),
sizeof(PhongDrawUniform));
if(data.flags & PhongGL::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform,
0*data.uniformIncrement*sizeof(TextureTransformationUniform),
sizeof(TextureTransformationUniform));
shader.draw(sphere);
shader.bindMaterialBuffer(materialUniform,
0*data.uniformIncrement*sizeof(PhongMaterialUniform),
sizeof(PhongMaterialUniform));
shader.bindLightBuffer(lightUniform,
2*data.uniformIncrement*sizeof(PhongLightUniform),
2*sizeof(PhongLightUniform));
shader.bindTransformationBuffer(transformationUniform,
1*data.uniformIncrement*sizeof(TransformationUniform3D),
sizeof(TransformationUniform3D));
shader.bindDrawBuffer(drawUniform,
1*data.uniformIncrement*sizeof(PhongDrawUniform),
sizeof(PhongDrawUniform));
if(data.flags & PhongGL::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform,
1*data.uniformIncrement*sizeof(TextureTransformationUniform),
sizeof(TextureTransformationUniform));
shader.draw(plane);
shader.bindMaterialBuffer(materialUniform,
1*data.uniformIncrement*sizeof(PhongMaterialUniform),
sizeof(PhongMaterialUniform));
shader.bindLightBuffer(lightUniform,
0*data.uniformIncrement*sizeof(PhongLightUniform),
2*sizeof(PhongLightUniform));
shader.bindTransformationBuffer(transformationUniform,
2*data.uniformIncrement*sizeof(TransformationUniform3D),
sizeof(TransformationUniform3D));
shader.bindDrawBuffer(drawUniform,
2*data.uniformIncrement*sizeof(PhongDrawUniform),
sizeof(PhongDrawUniform));
if(data.flags & PhongGL::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.bindTransformationBuffer(transformationUniform)
.bindDrawBuffer(drawUniform)
.bindMaterialBuffer(materialUniform)
.bindLightBuffer(lightUniform);
if(data.flags & PhongGL::Flag::TextureTransformation)
shader.bindTextureTransformationBuffer(textureTransformationUniform);
Shaders: multidraw support in all builtin shaders.
5 years ago
if(data.flags >= PhongGL::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
}
/*
Colored case:
- Sphere should be lower left, yellow with a white light with red and
green highlight on bottom left and right part
- Plane lower right, cyan with a magenta light so blue
- Cone up center, yellow with a cyan light so green
Textured case:
- Sphere should have bottom left numbers, so light 7881, rotated (78
visible)
- Plane bottom right, 1223
- Cone 6778
*/
MAGNUM_VERIFY_NO_GL_ERROR();
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, "PhongTestFiles", data.expected}),
(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 Phong shader. Currently fails for some combinations.
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::PhongGLTest)