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

1084 lines
50 KiB
Raw Normal View History Unescape

New library with sample shaders, currently only Phong shader.
14 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.
4 years ago
2020, 2021, 2022 Vladimír Vondruš <mosra@centrum.cz>
Doc++, updated changelog.
4 years ago
Copyright © 2022 Vladislav Oleshko <vladislav.oleshko@gmail.com>
Relicensing to MIT/Expat license, part 3: source files. Added license header also to shader sources. Hopefully it won't harm compilation times too much.
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.
New library with sample shaders, currently only Phong shader.
14 years ago
*/
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
#include "PhongGL.h"
New library with sample shaders, currently only Phong shader.
14 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
#if defined(MAGNUM_TARGET_GLES) || defined(MAGNUM_BUILD_DEPRECATED)
Shaders: support multiple lights in Phong.
8 years ago
#include <Corrade/Containers/Array.h>
#endif
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
#include <Corrade/Containers/EnumSet.hpp>
GL: better handle a case of async link failures. The new async APIs were just checking the link status, and printing the linker error. Because drivers commonly do all that in a single step, without really separating compilation from linking (or at least that's what I thought?), I assumed the linker error would contain *also* the compilation error, if any. But on a quick check with Mesa that's not the case, I only get "error: linking with uncompiled/unspecialized shader", which is very useless. Which means, to get proper error output, the checkLink() function now explicitly takes a list of the input shaders. It will unconditionally go through them at the beginning and call checkCompile() on each. To further encourage the shaders to be passed, there's no default argument -- so if the application calls checkCompile() on its own for some reason, it has to pass an empty list to checkLink().
4 years ago
#include <Corrade/Containers/Iterable.h>
Shaders: use StringViews to make code generation a bit less shitty. Also it seems the reserve() call was wrong.
6 years ago
#include <Corrade/Containers/StringView.h>
Shaders: make the string building slightly less crazy.
5 years ago
#include <Corrade/Containers/StringStl.h>
Adapted to Corrade changes. Mostly missing includes now.
7 years ago
#include <Corrade/Utility/FormatStl.h>
Making includes absolute, part 4: using absolute includes for Corrade. Also adapted to some Corrade renames.
12 years ago
#include <Corrade/Utility/Resource.h>
New library with sample shaders, currently only Phong shader.
14 years ago
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
#include "Magnum/GL/Context.h"
#include "Magnum/GL/Extensions.h"
Shaders: avoid including GL/Shader.h in headers. The class is rather heavy (strings, STL vector) and it'll stay heavier than strictly needed even after the planned STL cleanup -- shader users should not bear the overhead of Array, StringView etc. that it needs in order to compile the shader sources. I might eventually come to a different conclusion (maybe separating GL::Shader population and usage like doing in Vulkan with CreateInfos), but right now this commit has the best available solution -- converting the instance to a lightweight class containing just ID and type, and then converting that back to a GL::Shader upon checking compilation/link status. While at it, also removed the not-strictly-needed Optional usage from the header. It wouldn't work with forward-declared GL::Shader anyway.
4 years ago
#include "Magnum/GL/Shader.h"
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
#include "Magnum/GL/Texture.h"
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
#include "Magnum/Math/Color.h"
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
#include "Magnum/Math/Matrix3.h"
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
#include "Magnum/Math/Matrix4.h"
Reduced #includes in headers. Magnum.h now doesn't include anything except OpenGL headers, thus changes in Math library don't trigger recompilation of everything, but only of things really depending on it. Math constants moved to separate file for similar reasons, de-inlined some functions to remove the need for some #includes.
14 years ago
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
#include "Magnum/GL/Buffer.h"
Shaders: support array textures in Flat and Phong.
5 years ago
#include "Magnum/GL/TextureArray.h"
Shaders: add UBO support to all shaders.
5 years ago
#endif
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
#include "Magnum/Shaders/Implementation/CreateCompatibilityShader.h"
Shader: more robust extension presence checking. Propagate the information about whether given extension is disabled to GLSL instead of doing the guesswork again from scratch.
12 years ago
New library with sample shaders, currently only Phong shader.
14 years ago
namespace Magnum { namespace Shaders {
Use functions to bind textures to shader rather than *Texture::bind(). Why did I do this: * It is more clean, shorter and nice looking with method chaining, i.e. instead of: shader.setColor(...) .setOtherParam(5); texture1.bind(MyShader::Texture1Layer); texture2.bind(MyShader::Texture2Layer); We now have this: shader.setColor(...) .setOtherParam(5) .setTexture1(texture1) .setTexture2(texture2); * It is now also clear which texture type is expected, the layer constant did not say anything about type. * Also it is possible to use new features (multi bind, bindless textures etc.) while preserving the same public API. The only potential disadvantage is that the textures don't stay bound like uniform values do, but this become a non-issue with bindless textures. As usual, the old way is now deprecated and will be removed in some future release.
12 years ago
namespace {
enum: Int {
Shaders: NO, these are not layers.
6 years ago
AmbientTextureUnit = 0,
DiffuseTextureUnit = 1,
SpecularTextureUnit = 2,
Shaders: support object ID textures in the PhongGL shader.
4 years ago
NormalTextureUnit = 3,
/* 4 taken by MeshVisualizer colormap */
Shaders: implement object ID texture visualization in MeshVisualizer. Hah this took a while, as there was no texture scaffolding in place at all. Thus all this had to be added and tested for the first time: * 2D textures * 2D texture arrays * Texture transformation uniforms * Texture transformation UBOs * Instanced texture offset This also means that MeshVisualizer can be used to visualize arbitrary (single-channel) integer textures now, not just render meshes with object ID textures. Yay for feature parity!
4 years ago
ObjectIdTextureUnit = 5 /* shared with Flat and MeshVisualizer */
Use functions to bind textures to shader rather than *Texture::bind(). Why did I do this: * It is more clean, shorter and nice looking with method chaining, i.e. instead of: shader.setColor(...) .setOtherParam(5); texture1.bind(MyShader::Texture1Layer); texture2.bind(MyShader::Texture2Layer); We now have this: shader.setColor(...) .setOtherParam(5) .setTexture1(texture1) .setTexture2(texture2); * It is now also clear which texture type is expected, the layer constant did not say anything about type. * Also it is possible to use new features (multi bind, bindless textures etc.) while preserving the same public API. The only potential disadvantage is that the textures don't stay bound like uniform values do, but this become a non-issue with bindless textures. As usual, the old way is now deprecated and will be removed in some future release.
12 years ago
};
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
enum: Int {
ProjectionBufferBinding = 0,
TransformationBufferBinding = 1,
DrawBufferBinding = 2,
TextureTransformationBufferBinding = 3,
MaterialBufferBinding = 4,
LightBufferBinding = 5
};
#endif
Use functions to bind textures to shader rather than *Texture::bind(). Why did I do this: * It is more clean, shorter and nice looking with method chaining, i.e. instead of: shader.setColor(...) .setOtherParam(5); texture1.bind(MyShader::Texture1Layer); texture2.bind(MyShader::Texture2Layer); We now have this: shader.setColor(...) .setOtherParam(5) .setTexture1(texture1) .setTexture2(texture2); * It is now also clear which texture type is expected, the layer constant did not say anything about type. * Also it is possible to use new features (multi bind, bindless textures etc.) while preserving the same public API. The only potential disadvantage is that the textures don't stay bound like uniform values do, but this become a non-issue with bindless textures. As usual, the old way is now deprecated and will be removed in some future release.
12 years ago
}
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
PhongGL::CompileState PhongGL::compile(const Configuration& configuration) {
Shaders: implement async shader compilation for all shaders.
4 years ago
#ifndef CORRADE_NO_ASSERT
Shaders: support object ID textures in the PhongGL shader.
4 years ago
{
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
const bool textureTransformationNotEnabledOrTextured = !(configuration.flags() & Flag::TextureTransformation) || (configuration.flags() & (Flag::AmbientTexture|Flag::DiffuseTexture|Flag::SpecularTexture|Flag::NormalTexture))
Shaders: support object ID textures in the PhongGL shader.
4 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
|| configuration.flags() >= Flag::ObjectIdTexture
Shaders: support object ID textures in the PhongGL shader.
4 years ago
#endif
;
CORRADE_ASSERT(textureTransformationNotEnabledOrTextured,
Shaders: implement async shader compilation for all shaders.
4 years ago
"Shaders::PhongGL: texture transformation enabled but the shader is not textured", CompileState{NoCreate});
Shaders: support object ID textures in the PhongGL shader.
4 years ago
}
Shaders: implement async shader compilation for all shaders.
4 years ago
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
Shaders: 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: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
CORRADE_ASSERT(!(configuration.flags() >= Flag::InstancedObjectId) || !(configuration.flags() & Flag::Bitangent),
Shaders: implement async shader compilation for all shaders.
4 years ago
"Shaders::PhongGL: Bitangent attribute binding conflicts with the ObjectId attribute, use a Tangent4 attribute with instanced object ID rendering instead", CompileState{NoCreate});
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
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
CORRADE_ASSERT(!(configuration.flags() >= Flag::UniformBuffers) || configuration.materialCount(),
Shaders: implement async shader compilation for all shaders.
4 years ago
"Shaders::PhongGL: material count can't be zero", CompileState{NoCreate});
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
CORRADE_ASSERT(!(configuration.flags() >= Flag::UniformBuffers) || configuration.drawCount(),
Shaders: implement async shader compilation for all shaders.
4 years ago
"Shaders::PhongGL: draw count can't be zero", CompileState{NoCreate});
Shaders: add UBO support to all shaders.
5 years ago
#endif
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
CORRADE_ASSERT(!(configuration.flags() & Flag::TextureArrays) || (configuration.flags() & (Flag::AmbientTexture|Flag::DiffuseTexture|Flag::SpecularTexture|Flag::NormalTexture)) || configuration.flags() >= Flag::ObjectIdTexture,
Shaders: implement async shader compilation for all shaders.
4 years ago
"Shaders::PhongGL: texture arrays enabled but the shader is not textured", CompileState{NoCreate});
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
CORRADE_ASSERT(!(configuration.flags() & Flag::UniformBuffers) || !(configuration.flags() & Flag::TextureArrays) || configuration.flags() >= (Flag::TextureArrays|Flag::TextureTransformation),
Shaders: implement async shader compilation for all shaders.
4 years ago
"Shaders::PhongGL: texture arrays require texture transformation enabled as well if uniform buffers are used", CompileState{NoCreate});
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
CORRADE_ASSERT(!(configuration.flags() & Flag::LightCulling) || (configuration.flags() & Flag::UniformBuffers),
Shaders: implement async shader compilation for all shaders.
4 years ago
"Shaders::PhongGL: light culling requires uniform buffers to be enabled", CompileState{NoCreate});
Shaders: support array textures in Flat and Phong.
5 years ago
#endif
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
CORRADE_ASSERT(!(configuration.flags() & Flag::SpecularTexture) || !(configuration.flags() & (Flag::NoSpecular)),
Shaders: implement async shader compilation for all shaders.
4 years ago
"Shaders::PhongGL: specular texture requires the shader to not have specular disabled", CompileState{NoCreate});
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() >= Flag::UniformBuffers)
Shaders: add UBO support to all shaders.
5 years ago
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::ARB::uniform_buffer_object);
#endif
Shaders: multidraw support in all builtin shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() >= Flag::MultiDraw) {
Shaders: multidraw support in all builtin shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::ARB::shader_draw_parameters);
#elif !defined(MAGNUM_TARGET_WEBGL)
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::ANGLE::multi_draw);
#else
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::WEBGL::multi_draw);
#endif
}
#endif
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() >= Flag::TextureArrays)
Shaders: support array textures in Flat and Phong.
5 years ago
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::EXT::texture_array);
#endif
Shaders: add UBO support to all shaders.
5 years ago
Better handling of compiled-in resources in static build. Each class/function that needs to access the resources first checks whether the group exists and the group is registered if not. Thus there is now no difference and annoying special cases when using static build.
11 years ago
#ifdef MAGNUM_BUILD_STATIC
/* Import resources on static build, if not already */
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(!Utility::Resource::hasGroup("MagnumShadersGL"))
Better handling of compiled-in resources in static build. Each class/function that needs to access the resources first checks whether the group exists and the group is registered if not. Thus there is now no difference and annoying special cases when using static build.
11 years ago
importShaderResources();
#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
Utility::Resource rs("MagnumShadersGL");
PhongShader: fall back to GLSL 1.20 if 3.30/3.20 is not supported.
14 years ago
Shaders: avoid repeated GL::Context::current() calls. It involves a TLS lookup each time and it's just unnecessary extra typing.
5 years ago
const GL::Context& context = GL::Context::current();
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
CORRADE_ASSERT(!(configuration.flags() >= Flag::UniformBuffers) || context.isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>(),
Shaders: implement async shader compilation for all shaders.
4 years ago
"Shaders::PhongGL: uniform buffers require" << GL::Extensions::ARB::uniform_buffer_object::string(), CompileState{NoCreate});
Shaders: add UBO support to all shaders.
5 years ago
#endif
Blind port of PhongShader to OpenGL ES 2.0.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Shaders: avoid repeated GL::Context::current() calls. It involves a TLS lookup each time and it's just unnecessary extra typing.
5 years ago
const GL::Version version = context.supportedVersion({GL::Version::GL320, GL::Version::GL310, GL::Version::GL300, GL::Version::GL210});
Blind port of PhongShader to OpenGL ES 2.0.
14 years ago
#else
Shaders: avoid repeated GL::Context::current() calls. It involves a TLS lookup each time and it's just unnecessary extra typing.
5 years ago
const GL::Version version = context.supportedVersion({GL::Version::GLES300, GL::Version::GLES200});
Blind port of PhongShader to OpenGL ES 2.0.
14 years ago
#endif
Shaders: implement async shader compilation for all shaders.
4 years ago
PhongGL out{NoInit};
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
out._flags = configuration.flags();
out._lightCount = configuration.lightCount();
out._lightColorsUniform = out._lightPositionsUniform + Int(configuration.lightCount());
out._lightSpecularColorsUniform = out._lightPositionsUniform + 2*Int(configuration.lightCount());
out._lightRangesUniform = out._lightPositionsUniform + 3*Int(configuration.lightCount());
Shaders: implement async shader compilation for all shaders.
4 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
out._materialCount = configuration.materialCount();
out._drawCount = configuration.drawCount();
Shaders: implement async shader compilation for all shaders.
4 years ago
#endif
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
GL::Shader vert = Implementation::createCompatibilityShader(rs, version, GL::Shader::Type::Vertex);
GL::Shader frag = Implementation::createCompatibilityShader(rs, version, GL::Shader::Type::Fragment);
Shaders: making use of parallel compilation. Compiling fragment and vertex shader simultaenously, at least. Nothing more can be done for now. Also removed weird duplicate compile/link calls from MeshVisualizer, went unnoticed since b9a72bd3d1fd2bf763ca43a8cde7726583b671c2. Why did I do that?!
12 years ago
Shaders: support multiple lights in Phong.
8 years ago
#ifndef MAGNUM_TARGET_GLES
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
std::string lightInitializer;
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(!(configuration.flags() >= Flag::UniformBuffers) && configuration.lightCount()) {
Shaders: use StringViews to make code generation a bit less shitty. Also it seems the reserve() call was wrong.
6 years ago
using namespace Containers::Literals;
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
/* Initializer for the light color / position / range arrays -- we need
a list of initializers joined by commas. For GLES we'll simply
upload the values directly. */
constexpr Containers::StringView lightPositionInitializerPreamble = "#define LIGHT_POSITION_INITIALIZER "_s;
constexpr Containers::StringView lightColorInitializerPreamble = "#define LIGHT_COLOR_INITIALIZER "_s;
constexpr Containers::StringView lightRangeInitializerPreamble = "#define LIGHT_RANGE_INITIALIZER "_s;
constexpr Containers::StringView lightPositionInitializerItem = "vec4(0.0, 0.0, 1.0, 0.0), "_s;
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
constexpr Containers::StringView lightColorInitializerItem = "vec3(1.0), "_s;
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
constexpr Containers::StringView lightRangeInitializerItem = "1.0/0.0, "_s;
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer.reserve(
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
lightPositionInitializerPreamble.size() +
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightColorInitializerPreamble.size() +
lightRangeInitializerPreamble.size() +
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
configuration.lightCount()*(lightPositionInitializerItem.size() +
lightColorInitializerItem.size() +
lightRangeInitializerItem.size()));
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: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer.append(lightPositionInitializerPreamble);
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
for(std::size_t i = 0; i != configuration.lightCount(); ++i)
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer.append(lightPositionInitializerItem);
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
/* Drop the last comma and add a newline at the end */
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer[lightInitializer.size() - 2] = '\n';
lightInitializer.resize(lightInitializer.size() - 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
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer.append(lightColorInitializerPreamble);
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
for(std::size_t i = 0; i != configuration.lightCount(); ++i)
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer.append(lightColorInitializerItem);
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
/* Drop the last comma and add a newline at the end */
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer[lightInitializer.size() - 2] = '\n';
lightInitializer.resize(lightInitializer.size() - 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
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer.append(lightRangeInitializerPreamble);
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
for(std::size_t i = 0; i != configuration.lightCount(); ++i)
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer.append(lightRangeInitializerItem);
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
/* Drop the last comma and add a newline at the end */
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
lightInitializer[lightInitializer.size() - 2] = '\n';
lightInitializer.resize(lightInitializer.size() - 1);
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: support multiple lights in Phong.
8 years ago
#endif
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
vert.addSource((configuration.flags() & (Flag::AmbientTexture|Flag::DiffuseTexture|Flag::SpecularTexture|Flag::NormalTexture)
Shaders: support object ID textures in the PhongGL shader.
4 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
|| configuration.flags() >= Flag::ObjectIdTexture
Shaders: support object ID textures in the PhongGL shader.
4 years ago
#endif
) ? "#define TEXTURED\n" : "")
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
.addSource(configuration.flags() & Flag::NormalTexture ? "#define NORMAL_TEXTURE\n" : "")
.addSource(configuration.flags() & Flag::Bitangent ? "#define BITANGENT\n" : "")
.addSource(configuration.flags() & Flag::VertexColor ? "#define VERTEX_COLOR\n" : "")
.addSource(configuration.flags() & Flag::TextureTransformation ? "#define TEXTURE_TRANSFORMATION\n" : "")
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
.addSource(configuration.flags() & Flag::TextureArrays ? "#define TEXTURE_ARRAYS\n" : "")
Shaders: support array textures in Flat and Phong.
5 years ago
#endif
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
.addSource(configuration.lightCount() ? "#define HAS_LIGHTS\n" : "")
Shaders: ability to render instanced object ID in Flat/Phong.
6 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
.addSource(configuration.flags() >= Flag::InstancedObjectId ? "#define INSTANCED_OBJECT_ID\n" : "")
Shaders: ability to render instanced object ID in Flat/Phong.
6 years ago
#endif
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
.addSource(configuration.flags() & Flag::InstancedTransformation ? "#define INSTANCED_TRANSFORMATION\n" : "")
.addSource(configuration.flags() >= Flag::InstancedTextureOffset ? "#define INSTANCED_TEXTURE_OFFSET\n" : "");
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() >= Flag::UniformBuffers) {
Shaders: add UBO support to all shaders.
5 years ago
vert.addSource(Utility::formatString(
"#define UNIFORM_BUFFERS\n"
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
"#define DRAW_COUNT {}\n",
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
configuration.drawCount(),
configuration.lightCount()));
vert.addSource(configuration.flags() >= Flag::MultiDraw ? "#define MULTI_DRAW\n" : "");
Shaders: add UBO support to all shaders.
5 years ago
}
#endif
Adapt to Corrade changes.
4 years ago
vert.addSource(rs.getString("generic.glsl"))
.addSource(rs.getString("Phong.vert"));
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
frag.addSource(configuration.flags() & Flag::AmbientTexture ? "#define AMBIENT_TEXTURE\n" : "")
.addSource(configuration.flags() & Flag::DiffuseTexture ? "#define DIFFUSE_TEXTURE\n" : "")
.addSource(configuration.flags() & Flag::SpecularTexture ? "#define SPECULAR_TEXTURE\n" : "")
.addSource(configuration.flags() & Flag::NormalTexture ? "#define NORMAL_TEXTURE\n" : "")
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
.addSource(configuration.flags() & Flag::TextureArrays ? "#define TEXTURE_ARRAYS\n" : "")
Shaders: support array textures in Flat and Phong.
5 years ago
#endif
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
.addSource(configuration.flags() & Flag::Bitangent ? "#define BITANGENT\n" : "")
.addSource(configuration.flags() & Flag::VertexColor ? "#define VERTEX_COLOR\n" : "")
.addSource(configuration.flags() & Flag::AlphaMask ? "#define ALPHA_MASK\n" : "")
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
.addSource(configuration.flags() & Flag::ObjectId ? "#define OBJECT_ID\n" : "")
.addSource(configuration.flags() >= Flag::InstancedObjectId ? "#define INSTANCED_OBJECT_ID\n" : "")
.addSource(configuration.flags() >= Flag::ObjectIdTexture ? "#define OBJECT_ID_TEXTURE\n" : "")
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
.addSource(configuration.flags() & Flag::NoSpecular ? "#define NO_SPECULAR\n" : "")
Shaders: add UBO support to all shaders.
5 years ago
;
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() >= Flag::UniformBuffers) {
Shaders: add UBO support to all shaders.
5 years ago
frag.addSource(Utility::formatString(
"#define UNIFORM_BUFFERS\n"
"#define DRAW_COUNT {}\n"
"#define MATERIAL_COUNT {}\n"
"#define LIGHT_COUNT {}\n",
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
configuration.drawCount(),
configuration.materialCount(),
configuration.lightCount()));
frag.addSource(configuration.flags() >= Flag::MultiDraw ? "#define MULTI_DRAW\n" : "")
.addSource(configuration.flags() >= Flag::LightCulling ? "#define LIGHT_CULLING\n" : "");
Shaders: add UBO support to all shaders.
5 years ago
} else
#endif
{
frag.addSource(Utility::formatString(
Shaders: support multiple lights in Phong.
8 years ago
"#define LIGHT_COUNT {}\n"
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
"#define LIGHT_COLORS_LOCATION {}\n"
Shaders: add an ability to control specular light color to Phong.
6 years ago
"#define LIGHT_SPECULAR_COLORS_LOCATION {}\n"
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
"#define LIGHT_RANGES_LOCATION {}\n",
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
configuration.lightCount(),
Shaders: reuse already-calculated uniform locations in Phong.
3 years ago
out._lightColorsUniform,
out._lightSpecularColorsUniform,
out._lightRangesUniform));
Shaders: add UBO support to all shaders.
5 years ago
}
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_GLES
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(!(configuration.flags() >= Flag::UniformBuffers) && configuration.lightCount())
Shaders: calculate Phong light directions in the fragment shader. Hm, I wonder why I did it this way, the operation isn't really heavy to benefit from the hardware interpolators, and with a lot of lights we'd hit the maximum output count in the vertex shader. With classic uniforms this seems to be ~5% faster on both Intel and AMD cards. With UBOs this is ~15% (!) faster on AMD (I guess because the constant UBO access overhead is moved to just one stage instead of both?) but slower on Intel (of course, sigh... I assume due to UBO reads being slow and so when done for every fragment instead of every vertex it costs more?). Since this benefits the *real* GPUs while the card that was already awful is more awful I don't think that's a big deal. This change stays.
5 years ago
frag.addSource(std::move(lightInitializer));
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
Adapt to Corrade changes.
4 years ago
frag.addSource(rs.getString("generic.glsl"))
.addSource(rs.getString("Phong.frag"));
Shaders: making use of parallel compilation. Compiling fragment and vertex shader simultaenously, at least. Nothing more can be done for now. Also removed weird duplicate compile/link calls from MeshVisualizer, went unnoticed since b9a72bd3d1fd2bf763ca43a8cde7726583b671c2. Why did I do that?!
12 years ago
Shaders: implement async shader compilation for all shaders.
4 years ago
vert.submitCompile();
frag.submitCompile();
Shaders: making use of parallel compilation. Compiling fragment and vertex shader simultaenously, at least. Nothing more can be done for now. Also removed weird duplicate compile/link calls from MeshVisualizer, went unnoticed since b9a72bd3d1fd2bf763ca43a8cde7726583b671c2. Why did I do that?!
12 years ago
Shaders: implement async shader compilation for all shaders.
4 years ago
out.attachShaders({vert, frag});
Blind port of PhongShader to OpenGL ES 2.0.
14 years ago
Shaders: support object ID output in Flat and Phong.
7 years ago
/* ES3 has this done in the shader directly and doesn't even provide
bindFragmentDataLocation() */
Shaders: don't test for ES3 at runtime. This only generates code that will be never executed. Tested with Flat and Phong, the other shaders don't have rendering tests yet but since the change is the same, I assume it will work there as well.
7 years ago
#if !defined(MAGNUM_TARGET_GLES) || defined(MAGNUM_TARGET_GLES2)
Blind port of PhongShader to OpenGL ES 2.0.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Shaders: avoid repeated GL::Context::current() calls. It involves a TLS lookup each time and it's just unnecessary extra typing.
5 years ago
if(!context.isExtensionSupported<GL::Extensions::ARB::explicit_attrib_location>(version))
Blind port of PhongShader to OpenGL ES 2.0.
14 years ago
#endif
Shaders: minor tweaks. Non-matching number of opening and closing braces confused editors with code folding feature.
13 years ago
{
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(Position::Location, "position");
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.lightCount())
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(Normal::Location, "normal");
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if((configuration.flags() & Flag::NormalTexture) && configuration.lightCount()) {
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(Tangent::Location, "tangent");
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() & Flag::Bitangent)
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(Bitangent::Location, "bitangent");
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
}
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() & Flag::VertexColor)
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(Color3::Location, "vertexColor"); /* Color4 is the same */
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() & (Flag::AmbientTexture|Flag::DiffuseTexture|Flag::SpecularTexture)
Shaders: support object ID textures in the PhongGL shader.
4 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
|| configuration.flags() >= Flag::ObjectIdTexture
Shaders: support object ID textures in the PhongGL shader.
4 years ago
#endif
)
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(TextureCoordinates::Location, "textureCoordinates");
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() & Flag::ObjectId) {
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindFragmentDataLocation(ColorOutput, "color");
out.bindFragmentDataLocation(ObjectIdOutput, "objectId");
Shaders: support object ID output in Flat and Phong.
7 years ago
}
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() >= Flag::InstancedObjectId)
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(ObjectId::Location, "instanceObjectId");
Shaders: make instancing finally work on ES2 / WebGL 1. This was stupid, eh? Blame Mesa and SwiftShader for not exposing ANGLE_instanced_arrays so the only way to test this for me was via the browser, which is practically impossible. Then found this by an accident. Pushing straight to master because YOLO.
6 years ago
#endif
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() & Flag::InstancedTransformation) {
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(TransformationMatrix::Location, "instancedTransformationMatrix");
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.lightCount())
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(NormalMatrix::Location, "instancedNormalMatrix");
Shaders: properly bind the instancedNormalMatrix PhongGL attribute. It was only bound via the explicit binding, which isn't in GLES2. Yet however it just worked, everywhere I tested, somehow.
4 years ago
}
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
if(configuration.flags() >= Flag::InstancedTextureOffset)
Shaders: implement async shader compilation for all shaders.
4 years ago
out.bindAttributeLocation(TextureOffset::Location, "instancedTextureOffset");
PhongShader: fall back to GLSL 1.20 if 3.30/3.20 is not supported.
14 years ago
}
Shaders: don't test for ES3 at runtime. This only generates code that will be never executed. Tested with Flat and Phong, the other shaders don't have rendering tests yet but since the change is the same, I assume it will work there as well.
7 years ago
#endif
New library with sample shaders, currently only Phong shader.
14 years ago
Shaders: implement async shader compilation for all shaders.
4 years ago
out.submitLink();
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
}
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
PhongGL::CompileState PhongGL::compile() {
return compile(Configuration{});
}
#ifdef MAGNUM_BUILD_DEPRECATED
PhongGL::CompileState PhongGL::compile(const Flags flags, const UnsignedInt lightCount) {
return compile(Configuration{}
.setFlags(flags)
.setLightCount(lightCount));
}
#ifndef MAGNUM_TARGET_GLES2
PhongGL::CompileState PhongGL::compile(const Flags flags, const UnsignedInt lightCount, const UnsignedInt materialCount, const UnsignedInt drawCount) {
return compile(Configuration{}
.setFlags(flags)
.setLightCount(lightCount)
.setMaterialCount(materialCount)
.setDrawCount(drawCount));
}
#endif
#endif
Shaders: minor cleanup & document new async compilation APIs. Apart from docs mostly just reordering declaratios, removing usage of auto and providing default arguments where missing.
4 years ago
PhongGL::PhongGL(CompileState&& state): PhongGL{static_cast<PhongGL&&>(std::move(state))} {
Shaders: the early exit is only for assertion testing, document that. I knew it had to be there, but then forgot and wanted to remove it as superfluous because such case can't happen from user code. Well...
4 years ago
#ifdef CORRADE_GRACEFUL_ASSERT
/* When graceful assertions fire from within compile(), we get a NoCreate'd
CompileState. Exiting makes it possible to test the assert. */
Shaders: minor cleanup & document new async compilation APIs. Apart from docs mostly just reordering declaratios, removing usage of auto and providing default arguments where missing.
4 years ago
if(!id()) return;
Shaders: the early exit is only for assertion testing, document that. I knew it had to be there, but then forgot and wanted to remove it as superfluous because such case can't happen from user code. Well...
4 years ago
#endif
Shaders: implement async shader compilation for all shaders.
4 years ago
Shaders: avoid including GL/Shader.h in headers. The class is rather heavy (strings, STL vector) and it'll stay heavier than strictly needed even after the planned STL cleanup -- shader users should not bear the overhead of Array, StringView etc. that it needs in order to compile the shader sources. I might eventually come to a different conclusion (maybe separating GL::Shader population and usage like doing in Vulkan with CreateInfos), but right now this commit has the best available solution -- converting the instance to a lightweight class containing just ID and type, and then converting that back to a GL::Shader upon checking compilation/link status. While at it, also removed the not-strictly-needed Optional usage from the header. It wouldn't work with forward-declared GL::Shader anyway.
4 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink({GL::Shader(state._vert), GL::Shader(state._frag)}));
Shaders: implement async shader compilation for all shaders.
4 years ago
Using ARB_explicit_uniform_location in shaders. The backwards compatibility fully kills the purpose, but at least I can test the feature somewhere :-)
14 years ago
#ifndef MAGNUM_TARGET_GLES
Shaders: minor cleanup. * No need to repeat the type for all variables, unnecessary redundancy. * Reducing the amount of redundant local variables and if they stay making their definitions more localized to where they get used. * All uniform setters used the "initial value is" phrase instead of "default is", this one didn't.
3 years ago
const GL::Context& context = GL::Context::current();
if(!context.isExtensionSupported<GL::Extensions::ARB::explicit_uniform_location>(state._version))
Using ARB_explicit_uniform_location in shaders. The backwards compatibility fully kills the purpose, but at least I can test the feature somewhere :-)
14 years ago
#endif
Shaders: minor tweaks. Non-matching number of opening and closing braces confused editors with code folding feature.
13 years ago
{
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags >= Flag::UniformBuffers) {
Shaders: assume drawOffset is 0 if DRAW_COUNT is 1. This is always true in the single-draw case, since setDrawOffset() asserts on this. In the multi-draw case this optimization doesn't make sense, because it doesn't make sense to create a multidraw shader with just one draw. On an Intel 630 GPU this resulted in single-draw single-material Phong to go from 550 ms to 440, which is roughly a 20% improvement. For the simpler shaders the difference is even higher. The multidraw numbers stayed the same as before, obviously.
5 years ago
if(_drawCount > 1) _drawOffsetUniform = uniformLocation("drawOffset");
Shaders: add UBO support to all shaders.
5 years ago
} else
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: add UBO support to all shaders.
5 years ago
{
_transformationMatrixUniform = uniformLocation("transformationMatrix");
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::TextureTransformation)
Shaders: add UBO support to all shaders.
5 years ago
_textureMatrixUniform = uniformLocation("textureMatrix");
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::TextureArrays)
Shaders: support array textures in Flat and Phong.
5 years ago
_textureLayerUniform = uniformLocation("textureLayer");
#endif
Shaders: add UBO support to all shaders.
5 years ago
_projectionMatrixUniform = uniformLocation("projectionMatrix");
_ambientColorUniform = uniformLocation("ambientColor");
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_lightCount) {
Shaders: add UBO support to all shaders.
5 years ago
_normalMatrixUniform = uniformLocation("normalMatrix");
_diffuseColorUniform = uniformLocation("diffuseColor");
Shaders: implement async shader compilation for all shaders.
4 years ago
if(!(_flags & Flag::NoSpecular)) {
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
_specularColorUniform = uniformLocation("specularColor");
_shininessUniform = uniformLocation("shininess");
}
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::NormalTexture)
Shaders: add UBO support to all shaders.
5 years ago
_normalTextureScaleUniform = uniformLocation("normalTextureScale");
_lightPositionsUniform = uniformLocation("lightPositions");
_lightColorsUniform = uniformLocation("lightColors");
Shaders: implement async shader compilation for all shaders.
4 years ago
if(!(_flags & Flag::NoSpecular))
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
_lightSpecularColorsUniform = uniformLocation("lightSpecularColors");
Shaders: add UBO support to all shaders.
5 years ago
_lightRangesUniform = uniformLocation("lightRanges");
}
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::AlphaMask) _alphaMaskUniform = uniformLocation("alphaMask");
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::ObjectId) _objectIdUniform = uniformLocation("objectId");
Shaders: add UBO support to all shaders.
5 years ago
#endif
}
Using ARB_explicit_uniform_location in shaders. The backwards compatibility fully kills the purpose, but at least I can test the feature somewhere :-)
14 years ago
}
Shaders: GLSL ES doesn't have default values for uniforms. If targetting GLSL ES the values are set on initialization explicitly from application.
14 years ago
Shaders: ambient, diffuse and specular texture support in Phong.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Shaders: minor cleanup. * No need to repeat the type for all variables, unnecessary redundancy. * Reducing the amount of redundant local variables and if they stay making their definitions more localized to where they get used. * All uniform setters used the "initial value is" phrase instead of "default is", this one didn't.
3 years ago
if(_flags && !context.isExtensionSupported<GL::Extensions::ARB::shading_language_420pack>(state._version))
Shaders: ambient, diffuse and specular texture support in Phong.
13 years ago
#endif
{
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::AmbientTexture) setUniform(uniformLocation("ambientTexture"), AmbientTextureUnit);
if(_lightCount) {
if(_flags & Flag::DiffuseTexture) setUniform(uniformLocation("diffuseTexture"), DiffuseTextureUnit);
if(_flags & Flag::SpecularTexture) setUniform(uniformLocation("specularTexture"), SpecularTextureUnit);
if(_flags & Flag::NormalTexture) setUniform(uniformLocation("normalTexture"), NormalTextureUnit);
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
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags >= Flag::ObjectIdTexture) setUniform(uniformLocation("objectIdTextureData"), ObjectIdTextureUnit);
if(_flags >= Flag::UniformBuffers) {
Shaders: add UBO support to all shaders.
5 years ago
setUniformBlockBinding(uniformBlockIndex("Projection"), ProjectionBufferBinding);
setUniformBlockBinding(uniformBlockIndex("Transformation"), TransformationBufferBinding);
setUniformBlockBinding(uniformBlockIndex("Draw"), DrawBufferBinding);
setUniformBlockBinding(uniformBlockIndex("Material"), MaterialBufferBinding);
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::TextureTransformation)
Shaders: add UBO support to all shaders.
5 years ago
setUniformBlockBinding(uniformBlockIndex("TextureTransformation"), TextureTransformationBufferBinding);
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_lightCount)
Shaders: add UBO support to all shaders.
5 years ago
setUniformBlockBinding(uniformBlockIndex("Light"), LightBufferBinding);
}
#endif
Shaders: ambient, diffuse and specular texture support in Phong.
13 years ago
}
Shaders: GLSL ES doesn't have default values for uniforms. If targetting GLSL ES the values are set on initialization explicitly from application.
14 years ago
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags >= Flag::UniformBuffers) {
Shaders: add UBO support to all shaders.
5 years ago
/* Draw offset is zero by default */
} else
#endif
{
/* Default to fully opaque white so we can see the textures */
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::AmbientTexture) setAmbientColor(Magnum::Color4{1.0f});
Shaders: add UBO support to all shaders.
5 years ago
else setAmbientColor(Magnum::Color4{0.0f});
setTransformationMatrix(Matrix4{Math::IdentityInit});
setProjectionMatrix(Matrix4{Math::IdentityInit});
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_lightCount) {
Shaders: add UBO support to all shaders.
5 years ago
setDiffuseColor(Magnum::Color4{1.0f});
Shaders: implement async shader compilation for all shaders.
4 years ago
if(!(_flags & Flag::NoSpecular)) {
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
setSpecularColor(Magnum::Color4{1.0f, 0.0f});
setShininess(80.0f);
}
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::NormalTexture)
Shaders: add UBO support to all shaders.
5 years ago
setNormalTextureScale(1.0f);
Shaders: implement async shader compilation for all shaders.
4 years ago
setLightPositions(Containers::Array<Vector4>{DirectInit, _lightCount, Vector4{0.0f, 0.0f, 1.0f, 0.0f}});
Containers::Array<Magnum::Color3> colors{DirectInit, _lightCount, Magnum::Color3{1.0f}};
Shaders: add UBO support to all shaders.
5 years ago
setLightColors(colors);
Shaders: implement async shader compilation for all shaders.
4 years ago
if(!(_flags & Flag::NoSpecular))
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
setLightSpecularColors(colors);
Shaders: implement async shader compilation for all shaders.
4 years ago
setLightRanges(Containers::Array<Float>{DirectInit, _lightCount, Constants::inf()});
Shaders: add UBO support to all shaders.
5 years ago
/* Light position is zero by default */
setNormalMatrix(Matrix3x3{Math::IdentityInit});
}
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::TextureTransformation)
Shaders: add UBO support to all shaders.
5 years ago
setTextureMatrix(Matrix3{Math::IdentityInit});
Shaders: support array textures in Flat and Phong.
5 years ago
/* Texture layer is zero by default */
Shaders: implement async shader compilation for all shaders.
4 years ago
if(_flags & Flag::AlphaMask) setAlphaMask(0.5f);
Shaders: add UBO support to all shaders.
5 years ago
/* Object ID is zero by default */
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: GLSL ES doesn't have default values for uniforms. If targetting GLSL ES the values are set on initialization explicitly from application.
14 years ago
#endif
New library with sample shaders, currently only Phong shader.
14 years ago
}
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
PhongGL::PhongGL(const Configuration& configuration): PhongGL{compile(configuration)} {}
Shaders: implement async shader compilation for all shaders.
4 years ago
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
PhongGL::PhongGL(): PhongGL{Configuration{}} {}
#ifdef MAGNUM_BUILD_DEPRECATED
PhongGL::PhongGL(const Flags flags, const UnsignedInt lightCount): PhongGL{Configuration{}
.setFlags(flags)
.setLightCount(lightCount)} {}
Shaders: implement async shader compilation for all shaders.
4 years ago
Shaders: take constructor arguments via a Configuration instance. Because it was no longer bearable with three UnsignedInt arguments in a row, especially when some of them are only available on a subset of platforms. And it would get even worse with introduction of planned features such as multiview or skinning. Backwards compatibility is in place, as always. To ensure nothing breaks, this commit still has all tests and snippets using the old API.
4 years ago
#ifndef MAGNUM_TARGET_GLES2
PhongGL::PhongGL(const Flags flags, const UnsignedInt lightCount, const UnsignedInt materialCount, const UnsignedInt drawCount): PhongGL{compile(Configuration{}
.setFlags(flags)
.setLightCount(lightCount)
.setMaterialCount(materialCount)
.setDrawCount(drawCount))} {}
#endif
Shaders: add UBO support to all shaders.
5 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& PhongGL::setAmbientColor(const Magnum::Color4& color) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setAmbientColor(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
setUniform(_ambientColorUniform, color);
return *this;
}
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& PhongGL::setDiffuseColor(const Magnum::Color4& color) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setDiffuseColor(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
if(_lightCount) setUniform(_diffuseColorUniform, color);
return *this;
}
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& PhongGL::setSpecularColor(const Magnum::Color4& color) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setSpecularColor(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
CORRADE_ASSERT(!(_flags >= Flag::NoSpecular),
"Shaders::PhongGL::setSpecularColor(): the shader was created with specular disabled", *this);
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
if(_lightCount) setUniform(_specularColorUniform, color);
return *this;
}
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& PhongGL::setShininess(Float shininess) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setShininess(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
CORRADE_ASSERT(!(_flags >= Flag::NoSpecular),
"Shaders::PhongGL::setShininess(): the shader was created with specular disabled", *this);
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
if(_lightCount) setUniform(_shininessUniform, shininess);
return *this;
}
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& PhongGL::setNormalTextureScale(const Float scale) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setNormalTextureScale(): the shader was created with uniform buffers enabled", *this);
#endif
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
CORRADE_ASSERT(_flags & Flag::NormalTexture,
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::setNormalTextureScale(): the shader was not created with normal texture enabled", *this);
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
if(_lightCount) setUniform(_normalTextureScaleUniform, scale);
return *this;
}
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& PhongGL::setAlphaMask(Float mask) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setAlphaMask(): the shader was created with uniform buffers enabled", *this);
#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
CORRADE_ASSERT(_flags & Flag::AlphaMask,
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", *this);
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
setUniform(_alphaMaskUniform, mask);
return *this;
}
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
PhongGL& PhongGL::setObjectId(UnsignedInt id) {
Shaders: add UBO support to all shaders.
5 years ago
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setObjectId(): the shader was created with uniform buffers enabled", *this);
Shaders: support object ID output in Flat and Phong.
7 years ago
CORRADE_ASSERT(_flags & Flag::ObjectId,
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", *this);
Shaders: support object ID output in Flat and Phong.
7 years ago
setUniform(_objectIdUniform, id);
return *this;
}
#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& PhongGL::setTransformationMatrix(const Matrix4& matrix) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setTransformationMatrix(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
setUniform(_transformationMatrixUniform, matrix);
return *this;
}
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& PhongGL::setNormalMatrix(const Matrix3x3& matrix) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setNormalMatrix(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
if(_lightCount) setUniform(_normalMatrixUniform, matrix);
return *this;
}
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& PhongGL::setProjectionMatrix(const Matrix4& matrix) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setProjectionMatrix(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
setUniform(_projectionMatrixUniform, matrix);
return *this;
}
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& PhongGL::setTextureMatrix(const Matrix3& matrix) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setTextureMatrix(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
CORRADE_ASSERT(_flags & Flag::TextureTransformation,
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", *this);
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
setUniform(_textureMatrixUniform, matrix);
return *this;
}
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
PhongGL& PhongGL::setTextureLayer(UnsignedInt id) {
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setTextureLayer(): the shader was created with uniform buffers enabled", *this);
CORRADE_ASSERT(_flags & Flag::TextureArrays,
"Shaders::PhongGL::setTextureLayer(): the shader was not created with texture arrays enabled", *this);
setUniform(_textureLayerUniform, id);
return *this;
}
#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& PhongGL::setLightPositions(const Containers::ArrayView<const Vector4> positions) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setLightPositions(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
CORRADE_ASSERT(_lightCount == positions.size(),
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::setLightPositions(): expected" << _lightCount << "items but got" << positions.size(), *this);
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(_lightCount) setUniform(_lightPositionsUniform, positions);
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
return *this;
}
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
/* It's light, but can't be in the header because MSVC needs to know the size
of Vector3 for the initializer list use */
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& PhongGL::setLightPositions(const std::initializer_list<Vector4> positions) {
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
return setLightPositions(Containers::arrayView(positions));
}
#ifdef MAGNUM_BUILD_DEPRECATED
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& PhongGL::setLightPositions(const Containers::ArrayView<const Vector3> positions) {
Adapt to Corrade changes.
5 years ago
Containers::Array<Vector4> fourComponent{NoInit, positions.size()};
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
for(std::size_t i = 0; i != positions.size(); ++i)
fourComponent[i] = Vector4{positions[i], 0.0f};
setLightPositions(fourComponent);
return *this;
}
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& PhongGL::setLightPositions(const std::initializer_list<Vector3> positions) {
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
CORRADE_IGNORE_DEPRECATED_PUSH
return setLightPositions(Containers::arrayView(positions));
CORRADE_IGNORE_DEPRECATED_POP
}
#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& PhongGL::setLightPosition(const UnsignedInt id, const Vector4& position) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setLightPosition(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: support multiple lights in Phong.
8 years ago
CORRADE_ASSERT(id < _lightCount,
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::setLightPosition(): light ID" << id << "is out of bounds for" << _lightCount << "lights", *this);
Shaders: support multiple lights in Phong.
8 years ago
setUniform(_lightPositionsUniform + id, position);
return *this;
}
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
#ifdef MAGNUM_BUILD_DEPRECATED
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& PhongGL::setLightPosition(UnsignedInt id, const Vector3& position) {
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
return setLightPosition(id, Vector4{position, 0.0f});
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
}
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
PhongGL& PhongGL::setLightPosition(const Vector3& position) {
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
/* Use the list variant to check the shader really has just one light */
return setLightPositions({Vector4{position, 0.0f}});
}
#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& PhongGL::setLightColors(const Containers::ArrayView<const Magnum::Color3> colors) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setLightColors(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
CORRADE_ASSERT(_lightCount == colors.size(),
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" << _lightCount << "items but got" << colors.size(), *this);
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(_lightCount) setUniform(_lightColorsUniform, colors);
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
return *this;
}
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
#ifdef MAGNUM_BUILD_DEPRECATED
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& PhongGL::setLightColors(const Containers::ArrayView<const Magnum::Color4> colors) {
Adapt to Corrade changes.
5 years ago
Containers::Array<Magnum::Color3> threeComponent{NoInit, colors.size()};
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
for(std::size_t i = 0; i != colors.size(); ++i)
threeComponent[i] = colors[i].rgb();
setLightColors(threeComponent);
return *this;
}
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& PhongGL::setLightColors(const std::initializer_list<Magnum::Color4> colors) {
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
CORRADE_IGNORE_DEPRECATED_PUSH
return setLightColors(Containers::arrayView(colors));
CORRADE_IGNORE_DEPRECATED_POP
}
#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& PhongGL::setLightColors(const std::initializer_list<Magnum::Color3> colors) {
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
return setLightColors(Containers::arrayView(colors));
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
}
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
PhongGL& PhongGL::setLightColor(const UnsignedInt id, const Magnum::Color3& color) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setLightColor(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: support multiple lights in Phong.
8 years ago
CORRADE_ASSERT(id < _lightCount,
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" << id << "is out of bounds for" << _lightCount << "lights", *this);
Shaders: support multiple lights in Phong.
8 years ago
setUniform(_lightColorsUniform + id, color);
return *this;
}
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
#ifdef MAGNUM_BUILD_DEPRECATED
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& PhongGL::setLightColor(UnsignedInt id, const Magnum::Color4& color) {
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
return setLightColor(id, color.rgb());
}
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& PhongGL::setLightColor(const Magnum::Color4& color) {
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
/* Use the list variant to check the shader really has just one light */
return setLightColors({color.rgb()});
}
#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& PhongGL::setLightSpecularColors(const Containers::ArrayView<const Magnum::Color3> colors) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setLightSpecularColors(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: add an ability to control specular light color to Phong.
6 years ago
CORRADE_ASSERT(_lightCount == colors.size(),
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::setLightSpecularColors(): expected" << _lightCount << "items but got" << colors.size(), *this);
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
CORRADE_ASSERT(!(_flags >= Flag::NoSpecular),
"Shaders::PhongGL::setLightSpecularColors(): the shader was created with specular disabled", *this);
Shaders: add an ability to control specular light color to Phong.
6 years ago
if(_lightCount) setUniform(_lightSpecularColorsUniform, colors);
return *this;
}
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& PhongGL::setLightSpecularColors(const std::initializer_list<Magnum::Color3> colors) {
Shaders: add an ability to control specular light color to Phong.
6 years ago
return setLightSpecularColors(Containers::arrayView(colors));
}
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& PhongGL::setLightSpecularColor(const UnsignedInt id, const Magnum::Color3& color) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setLightSpecularColor(): the shader was created with uniform buffers enabled", *this);
#endif
Shaders: add an ability to control specular light color to Phong.
6 years ago
CORRADE_ASSERT(id < _lightCount,
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::setLightSpecularColor(): light ID" << id << "is out of bounds for" << _lightCount << "lights", *this);
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
CORRADE_ASSERT(!(_flags >= Flag::NoSpecular),
"Shaders::PhongGL::setLightSpecularColor(): the shader was created with specular disabled", *this);
Shaders: add an ability to control specular light color to Phong.
6 years ago
setUniform(_lightSpecularColorsUniform + id, color);
return *this;
}
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& PhongGL::setLightRanges(const Containers::ArrayView<const Float> ranges) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setLightRanges(): the shader was created with uniform buffers enabled", *this);
#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
CORRADE_ASSERT(_lightCount == ranges.size(),
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::setLightRanges(): expected" << _lightCount << "items but got" << ranges.size(), *this);
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(_lightCount) setUniform(_lightRangesUniform, ranges);
return *this;
}
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& PhongGL::setLightRanges(const std::initializer_list<Float> ranges) {
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
return setLightRanges(Containers::arrayView(ranges));
}
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& PhongGL::setLightRange(const UnsignedInt id, const Float range) {
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),
"Shaders::PhongGL::setLightRange(): the shader was created with uniform buffers enabled", *this);
#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
CORRADE_ASSERT(id < _lightCount,
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::setLightRange(): light ID" << id << "is out of bounds for" << _lightCount << "lights", *this);
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
setUniform(_lightRangesUniform + id, range);
return *this;
}
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
PhongGL& PhongGL::setDrawOffset(const UnsignedInt offset) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::setDrawOffset(): the shader was not created with uniform buffers enabled", *this);
CORRADE_ASSERT(offset < _drawCount,
"Shaders::PhongGL::setDrawOffset(): draw offset" << offset << "is out of bounds for" << _drawCount << "draws", *this);
Shaders: assume drawOffset is 0 if DRAW_COUNT is 1. This is always true in the single-draw case, since setDrawOffset() asserts on this. In the multi-draw case this optimization doesn't make sense, because it doesn't make sense to create a multidraw shader with just one draw. On an Intel 630 GPU this resulted in single-draw single-material Phong to go from 550 ms to 440, which is roughly a 20% improvement. For the simpler shaders the difference is even higher. The multidraw numbers stayed the same as before, obviously.
5 years ago
if(_drawCount > 1) setUniform(_drawOffsetUniform, offset);
Shaders: add UBO support to all shaders.
5 years ago
return *this;
}
PhongGL& PhongGL::bindProjectionBuffer(GL::Buffer& buffer) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindProjectionBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, ProjectionBufferBinding);
return *this;
}
PhongGL& PhongGL::bindProjectionBuffer(GL::Buffer& buffer, const GLintptr offset, const GLsizeiptr size) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindProjectionBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, ProjectionBufferBinding, offset, size);
return *this;
}
PhongGL& PhongGL::bindTransformationBuffer(GL::Buffer& buffer) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindTransformationBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, TransformationBufferBinding);
return *this;
}
PhongGL& PhongGL::bindTransformationBuffer(GL::Buffer& buffer, const GLintptr offset, const GLsizeiptr size) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindTransformationBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, TransformationBufferBinding, offset, size);
return *this;
}
PhongGL& PhongGL::bindDrawBuffer(GL::Buffer& buffer) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindDrawBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, DrawBufferBinding);
return *this;
}
PhongGL& PhongGL::bindDrawBuffer(GL::Buffer& buffer, const GLintptr offset, const GLsizeiptr size) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindDrawBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, DrawBufferBinding, offset, size);
return *this;
}
PhongGL& PhongGL::bindTextureTransformationBuffer(GL::Buffer& buffer) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindTextureTransformationBuffer(): the shader was not created with uniform buffers enabled", *this);
CORRADE_ASSERT(_flags & Flag::TextureTransformation,
"Shaders::PhongGL::bindTextureTransformationBuffer(): the shader was not created with texture transformation enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, TextureTransformationBufferBinding);
return *this;
}
PhongGL& PhongGL::bindTextureTransformationBuffer(GL::Buffer& buffer, const GLintptr offset, const GLsizeiptr size) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindTextureTransformationBuffer(): the shader was not created with uniform buffers enabled", *this);
CORRADE_ASSERT(_flags & Flag::TextureTransformation,
"Shaders::PhongGL::bindTextureTransformationBuffer(): the shader was not created with texture transformation enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, TextureTransformationBufferBinding, offset, size);
return *this;
}
PhongGL& PhongGL::bindMaterialBuffer(GL::Buffer& buffer) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindMaterialBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, MaterialBufferBinding);
return *this;
}
PhongGL& PhongGL::bindMaterialBuffer(GL::Buffer& buffer, const GLintptr offset, const GLsizeiptr size) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindMaterialBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, MaterialBufferBinding, offset, size);
return *this;
}
PhongGL& PhongGL::bindLightBuffer(GL::Buffer& buffer) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindLightBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, LightBufferBinding);
return *this;
}
PhongGL& PhongGL::bindLightBuffer(GL::Buffer& buffer, const GLintptr offset, const GLsizeiptr size) {
CORRADE_ASSERT(_flags >= Flag::UniformBuffers,
"Shaders::PhongGL::bindLightBuffer(): the shader was not created with uniform buffers enabled", *this);
buffer.bind(GL::Buffer::Target::Uniform, LightBufferBinding, offset, size);
return *this;
}
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
PhongGL& PhongGL::bindAmbientTexture(GL::Texture2D& texture) {
CORRADE_ASSERT(_flags & Flag::AmbientTexture,
"Shaders::PhongGL::bindAmbientTexture(): the shader was not created with ambient texture enabled", *this);
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags & Flag::TextureArrays),
"Shaders::PhongGL::bindAmbientTexture(): the shader was created with texture arrays enabled, use a Texture2DArray instead", *this);
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
texture.bind(AmbientTextureUnit);
return *this;
}
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
PhongGL& PhongGL::bindAmbientTexture(GL::Texture2DArray& texture) {
CORRADE_ASSERT(_flags & Flag::AmbientTexture,
"Shaders::PhongGL::bindAmbientTexture(): the shader was not created with ambient texture enabled", *this);
CORRADE_ASSERT(_flags & Flag::TextureArrays,
"Shaders::PhongGL::bindAmbientTexture(): the shader was not created with texture arrays enabled, use a Texture2D instead", *this);
texture.bind(AmbientTextureUnit);
return *this;
}
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
PhongGL& PhongGL::bindDiffuseTexture(GL::Texture2D& texture) {
CORRADE_ASSERT(_flags & Flag::DiffuseTexture,
"Shaders::PhongGL::bindDiffuseTexture(): the shader was not created with diffuse texture enabled", *this);
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags & Flag::TextureArrays),
"Shaders::PhongGL::bindDiffuseTexture(): the shader was created with texture arrays enabled, use a Texture2DArray instead", *this);
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
if(_lightCount) texture.bind(DiffuseTextureUnit);
return *this;
}
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
PhongGL& PhongGL::bindDiffuseTexture(GL::Texture2DArray& texture) {
CORRADE_ASSERT(_flags & Flag::DiffuseTexture,
"Shaders::PhongGL::bindDiffuseTexture(): the shader was not created with diffuse texture enabled", *this);
CORRADE_ASSERT(_flags & Flag::TextureArrays,
"Shaders::PhongGL::bindDiffuseTexture(): the shader was not created with texture arrays enabled, use a Texture2D instead", *this);
if(_lightCount) texture.bind(DiffuseTextureUnit);
return *this;
}
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
PhongGL& PhongGL::bindSpecularTexture(GL::Texture2D& texture) {
CORRADE_ASSERT(_flags & Flag::SpecularTexture,
"Shaders::PhongGL::bindSpecularTexture(): the shader was not created with specular texture enabled", *this);
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags & Flag::TextureArrays),
"Shaders::PhongGL::bindSpecularTexture(): the shader was created with texture arrays enabled, use a Texture2DArray instead", *this);
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
if(_lightCount) texture.bind(SpecularTextureUnit);
return *this;
}
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
PhongGL& PhongGL::bindSpecularTexture(GL::Texture2DArray& texture) {
CORRADE_ASSERT(_flags & Flag::SpecularTexture,
"Shaders::PhongGL::bindSpecularTexture(): the shader was not created with specular texture enabled", *this);
CORRADE_ASSERT(_flags & Flag::TextureArrays,
"Shaders::PhongGL::bindSpecularTexture(): the shader was not created with texture arrays enabled, use a Texture2D instead", *this);
if(_lightCount) texture.bind(SpecularTextureUnit);
return *this;
}
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
PhongGL& PhongGL::bindNormalTexture(GL::Texture2D& texture) {
CORRADE_ASSERT(_flags & Flag::NormalTexture,
"Shaders::PhongGL::bindNormalTexture(): the shader was not created with normal texture enabled", *this);
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags & Flag::TextureArrays),
"Shaders::PhongGL::bindNormalTexture(): the shader was created with texture arrays enabled, use a Texture2DArray instead", *this);
#endif
if(_lightCount) texture.bind(NormalTextureUnit);
return *this;
}
#ifndef MAGNUM_TARGET_GLES2
PhongGL& PhongGL::bindNormalTexture(GL::Texture2DArray& texture) {
CORRADE_ASSERT(_flags & Flag::NormalTexture,
"Shaders::PhongGL::bindNormalTexture(): the shader was not created with normal texture enabled", *this);
CORRADE_ASSERT(_flags & Flag::TextureArrays,
"Shaders::PhongGL::bindNormalTexture(): the shader was not created with texture arrays enabled, use a Texture2D instead", *this);
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
if(_lightCount) texture.bind(NormalTextureUnit);
return *this;
}
Shaders: support array textures in Flat and Phong.
5 years ago
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
Shaders: support object ID textures in the PhongGL shader.
4 years ago
#ifndef MAGNUM_TARGET_GLES2
PhongGL& PhongGL::bindObjectIdTexture(GL::Texture2D& texture) {
CORRADE_ASSERT(_flags >= Flag::ObjectIdTexture,
"Shaders::PhongGL::bindObjectIdTexture(): the shader was not created with object ID texture enabled", *this);
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags & Flag::TextureArrays),
"Shaders::PhongGL::bindObjectIdTexture(): the shader was created with texture arrays enabled, use a Texture2DArray instead", *this);
#endif
texture.bind(ObjectIdTextureUnit);
return *this;
}
PhongGL& PhongGL::bindObjectIdTexture(GL::Texture2DArray& texture) {
CORRADE_ASSERT(_flags >= Flag::ObjectIdTexture,
"Shaders::PhongGL::bindObjectIdTexture(): the shader was not created with object ID texture enabled", *this);
CORRADE_ASSERT(_flags & Flag::TextureArrays,
"Shaders::PhongGL::bindObjectIdTexture(): the shader was not created with texture arrays enabled, use a Texture2D instead", *this);
texture.bind(ObjectIdTextureUnit);
return *this;
}
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
PhongGL& PhongGL::bindTextures(GL::Texture2D* ambient, GL::Texture2D* diffuse, GL::Texture2D* specular, GL::Texture2D* normal) {
CORRADE_ASSERT(_flags & (Flag::AmbientTexture|Flag::DiffuseTexture|Flag::SpecularTexture|Flag::NormalTexture),
"Shaders::PhongGL::bindTextures(): the shader was not created with any textures enabled", *this);
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags & Flag::TextureArrays),
"Shaders::PhongGL::bindTextures(): the shader was created with texture arrays enabled, use a Texture2DArray instead", *this);
#endif
Shaders: group uniform setters and texture binding functions together. Otherwise it would get way too messy with the introduction of uniform buffers.
5 years ago
GL::AbstractTexture::bind(AmbientTextureUnit, {ambient, diffuse, specular, normal});
return *this;
}
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
Debug& operator<<(Debug& debug, const PhongGL::Flag value) {
Shaders: support object ID textures in the PhongGL shader.
4 years ago
#ifndef MAGNUM_TARGET_GLES2
/* Special case coming from the Flags printer. As both flags are a superset
of ObjectId, printing just one would result in
`Flag::InstancedObjectId|Flag(0x20000)` in the output. */
if(value == PhongGL::Flag(UnsignedInt(PhongGL::Flag::InstancedObjectId|PhongGL::Flag::ObjectIdTexture)))
return debug << PhongGL::Flag::InstancedObjectId << Debug::nospace << "|" << Debug::nospace << PhongGL::Flag::ObjectIdTexture;
#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
debug << "Shaders::PhongGL::Flag" << Debug::nospace;
Reduce string duplication in enum debug output operators. Bloaty says it saved 10 kB in Debug build of MagnumGL: VM SIZE FILE SIZE -------------- -------------- [ = ] 0 .debug_info +1.59Ki +0.0% +0.4% +1.50Ki .text +1.50Ki +0.4% [ = ] 0 .debug_str +409 +0.0% [ = ] 0 .debug_line +276 +0.1% [ = ] 0 .debug_abbrev +20 +0.0% -28.6% -2 [LOAD [RX]] -2 -28.6% [ = ] 0 [Unmapped] -4.28Ki -41.0% -22.7% -9.23Ki .rodata -9.23Ki -22.7% -0.8% -7.73Ki TOTAL -9.73Ki -0.1% And 4 kB in Release: VM SIZE FILE SIZE -------------- -------------- +1.1% +3.44Ki .text +3.44Ki +1.1% +1.7% +1.39Ki .eh_frame +1.39Ki +1.7% [ = ] 0 [Unmapped] +656 +51% -25.5% -9.47Ki .rodata -9.47Ki -25.5% -0.7% -4.64Ki TOTAL -4.00Ki -0.4% That's not negative, so I guess that's good. This change is of course more significant in the context of a minimal WebGL build, where the exe can be as little as 50 kB -- there 4 kB is almost 10% of the size.
7 years ago
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
switch(value) {
/* LCOV_EXCL_START */
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
#define _c(v) case PhongGL::Flag::v: return debug << "::" #v;
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
_c(AmbientTexture)
_c(DiffuseTexture)
_c(SpecularTexture)
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
_c(NormalTexture)
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
_c(Bitangent)
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
_c(AlphaMask)
Shaders: vertex color support in Phong and Flat.
7 years ago
_c(VertexColor)
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
_c(TextureTransformation)
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
_c(ObjectId)
Shaders: support object ID textures in the PhongGL shader.
4 years ago
_c(InstancedObjectId)
_c(ObjectIdTexture)
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: implement instancing in Phong.
6 years ago
_c(InstancedTransformation)
_c(InstancedTextureOffset)
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
_c(UniformBuffers)
Shaders: multidraw support in all builtin shaders.
5 years ago
_c(MultiDraw)
Shaders: support array textures in Flat and Phong.
5 years ago
_c(TextureArrays)
Shaders: introduce Phong::Flag::LightCulling. After several failed attempts to make UBO performance not suck on Intel Mesa and Windows drivers, I ended up hiding the dynamic aspect under a flag. That way it's still possible to get the proper perf in UBO workflows that don't do light culling, and for workflows where light culling matters the 2x slowdown might be still better than looping through several extra lights that don't contribute anything.
5 years ago
_c(LightCulling)
Shaders: add UBO support to all shaders.
5 years ago
#endif
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
_c(NoSpecular)
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
#undef _c
/* LCOV_EXCL_STOP */
}
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedInt(value)) << Debug::nospace << ")";
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
}
Shaders: suffix all existing shaders with GL. To make room for Vulkan shaders. Also renaming the headers, of course everything is still aliased to the old names (and marked as deprecated).
5 years ago
Debug& operator<<(Debug& debug, const PhongGL::Flags value) {
return Containers::enumSetDebugOutput(debug, value, "Shaders::PhongGL::Flags{}", {
PhongGL::Flag::AmbientTexture,
PhongGL::Flag::DiffuseTexture,
PhongGL::Flag::SpecularTexture,
PhongGL::Flag::NormalTexture,
PhongGL::Flag::Bitangent,
PhongGL::Flag::AlphaMask,
PhongGL::Flag::VertexColor,
PhongGL::Flag::InstancedTextureOffset, /* Superset of TextureTransformation */
PhongGL::Flag::TextureTransformation,
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: support object ID textures in the PhongGL shader.
4 years ago
/* Both are a superset of ObjectId, meaning printing just one would
result in `Flag::InstancedObjectId|Flag(0x20000)` in the output. So
we pass both and let the Flag printer deal with that. */
PhongGL::Flag(UnsignedInt(PhongGL::Flag::InstancedObjectId|PhongGL::Flag::ObjectIdTexture)),
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::InstancedObjectId, /* Superset of ObjectId */
Shaders: support object ID textures in the PhongGL shader.
4 years ago
PhongGL::Flag::ObjectIdTexture, /* Superset of ObjectId */
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::ObjectId,
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: add UBO support to all shaders.
5 years ago
PhongGL::Flag::InstancedTransformation,
#ifndef MAGNUM_TARGET_GLES2
Shaders: multidraw support in all builtin shaders.
5 years ago
PhongGL::Flag::MultiDraw, /* Superset of UniformBuffers */
Shaders: support array textures in Flat and Phong.
5 years ago
PhongGL::Flag::UniformBuffers,
Shaders: introduce Phong::Flag::LightCulling. After several failed attempts to make UBO performance not suck on Intel Mesa and Windows drivers, I ended up hiding the dynamic aspect under a flag. That way it's still possible to get the proper perf in UBO workflows that don't do light culling, and for workflows where light culling matters the 2x slowdown might be still better than looping through several extra lights that don't contribute anything.
5 years ago
PhongGL::Flag::TextureArrays,
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
PhongGL::Flag::LightCulling,
Shaders: add UBO support to all shaders.
5 years ago
#endif
Shaders: ability to disable Phong specular contribution. In cases when specular highlights are not desired, results in 30% speedup (on Intel) and ~25% speedup on AMD, compared to setting the specular color to transparent black. Testing was easy thanks to already having a ground truth image for this case.
5 years ago
PhongGL::Flag::NoSpecular
Shaders: add UBO support to all shaders.
5 years ago
});
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
}
New library with sample shaders, currently only Phong shader.
14 years ago
}}