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

958 lines
42 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.
5 years ago
2020, 2021 Vladimír Vondruš <mosra@centrum.cz>
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>
Remove use of std::reference_wrapper where possible. What's left is *a lot* of places taking monstrous std::vector<std::reference_wrapper> and that can't be changed to std::vector<Containers::Reference> in a source-compatible way. Even that would be only a temporary change, since the goal is to fully avoid dependency on STL in those cases. The final version of these APIs should take Containers::ArrayView<Containers::Reference> and be implicitly convertible froom e.g. std::vector<Containers::Reference>. That's definitely possible, but not in time for 2019.01, so instead of forcing users to temporary pass a `{vec.begin(), vec.size()}` everywhere instead of just `vec`, I'm rather keeping these APIs intact.
7 years ago
#include <Corrade/Containers/Reference.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"
#include "Magnum/GL/Shader.h"
#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,
NormalTextureUnit = 3
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: add UBO support to all shaders.
5 years ago
PhongGL::PhongGL(const Flags flags, const UnsignedInt lightCount
#ifndef MAGNUM_TARGET_GLES2
, const UnsignedInt materialCount, const UnsignedInt drawCount
#endif
):
_flags{flags},
_lightCount{lightCount},
#ifndef MAGNUM_TARGET_GLES2
_materialCount{materialCount},
_drawCount{drawCount},
#endif
_lightColorsUniform{_lightPositionsUniform + Int(lightCount)},
_lightSpecularColorsUniform{_lightPositionsUniform + 2*Int(lightCount)},
_lightRangesUniform{_lightPositionsUniform + 3*Int(lightCount)}
{
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) || (flags & (Flag::AmbientTexture|Flag::DiffuseTexture|Flag::SpecularTexture|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: texture transformation enabled but the shader is not textured", );
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
CORRADE_ASSERT(!(flags & Flag::InstancedObjectId) || !(flags & Flag::Bitangent),
"Shaders::PhongGL: Bitangent attribute binding conflicts with the ObjectId attribute, use a Tangent4 attribute with instanced object ID rendering instead", );
#endif
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(flags >= Flag::UniformBuffers) || materialCount,
"Shaders::PhongGL: material count can't be zero", );
CORRADE_ASSERT(!(flags >= Flag::UniformBuffers) || drawCount,
"Shaders::PhongGL: draw count can't be zero", );
#endif
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(flags & Flag::TextureArrays) || (flags & (Flag::AmbientTexture|Flag::DiffuseTexture|Flag::SpecularTexture|Flag::NormalTexture)),
"Shaders::PhongGL: texture arrays enabled but the shader is not textured", );
CORRADE_ASSERT(!(flags & Flag::UniformBuffers) || !(flags & Flag::TextureArrays) || flags >= (Flag::TextureArrays|Flag::TextureTransformation),
"Shaders::PhongGL: texture arrays require texture transformation enabled as well if uniform buffers are used", );
#endif
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES
if(flags >= Flag::UniformBuffers)
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
if(flags >= Flag::MultiDraw) {
#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
if(flags >= Flag::TextureArrays)
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
CORRADE_ASSERT(!(flags >= Flag::UniformBuffers) || context.isExtensionSupported<GL::Extensions::ARB::uniform_buffer_object>(),
"Shaders::PhongGL: uniform buffers require" << GL::Extensions::ARB::uniform_buffer_object::string(), );
#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
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: 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
std::string lightInitializerVertex, lightInitializerFragment;
Shaders: add UBO support to all shaders.
5 years ago
if(!(flags >= Flag::UniformBuffers) && 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;
lightInitializerVertex.reserve(
lightPositionInitializerPreamble.size() +
lightCount*(lightPositionInitializerItem.size()));
Shaders: make the string building slightly less crazy.
5 years ago
lightInitializerVertex.append(lightPositionInitializerPreamble);
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
for(std::size_t i = 0; i != lightCount; ++i)
Shaders: make the string building slightly less crazy.
5 years ago
lightInitializerVertex.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: 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
lightInitializerVertex[lightInitializerVertex.size() - 2] = '\n';
lightInitializerVertex.resize(lightInitializerVertex.size() - 1);
lightInitializerFragment.reserve(
lightColorInitializerPreamble.size() +
lightRangeInitializerPreamble.size() +
lightCount*(lightColorInitializerItem.size() +
lightRangeInitializerItem.size()));
Shaders: make the string building slightly less crazy.
5 years ago
lightInitializerFragment.append(lightColorInitializerPreamble);
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 != lightCount; ++i)
Shaders: make the string building slightly less crazy.
5 years ago
lightInitializerFragment.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 */
lightInitializerFragment[lightInitializerFragment.size() - 2] = '\n';
lightInitializerFragment.resize(lightInitializerFragment.size() - 1);
Shaders: make the string building slightly less crazy.
5 years ago
lightInitializerFragment.append(lightRangeInitializerPreamble);
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 != lightCount; ++i)
Shaders: make the string building slightly less crazy.
5 years ago
lightInitializerFragment.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 */
lightInitializerFragment[lightInitializerFragment.size() - 2] = '\n';
lightInitializerFragment.resize(lightInitializerFragment.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: 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
vert.addSource(flags & (Flag::AmbientTexture|Flag::DiffuseTexture|Flag::SpecularTexture|Flag::NormalTexture) ? "#define TEXTURED\n" : "")
.addSource(flags & Flag::NormalTexture ? "#define NORMAL_TEXTURE\n" : "")
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
.addSource(flags & Flag::Bitangent ? "#define BITANGENT\n" : "")
Shaders: vertex color support in Phong and Flat.
7 years ago
.addSource(flags & Flag::VertexColor ? "#define VERTEX_COLOR\n" : "")
Shaders: implement texture coordinate transformation for all shaders. Except MeshVisualizer and VertexColor, which don't have any texturing, so there it's not needed. In most cases the tests are reusing existing ground truth files and only modifying transformations / flipping images.
6 years ago
.addSource(flags & Flag::TextureTransformation ? "#define TEXTURE_TRANSFORMATION\n" : "")
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
.addSource(flags & Flag::TextureArrays ? "#define TEXTURE_ARRAYS\n" : "")
#endif
Shaders: support multiple lights in Phong.
8 years ago
.addSource(Utility::formatString("#define LIGHT_COUNT {}\n", lightCount))
Shaders: ability to render instanced object ID in Flat/Phong.
6 years ago
#ifndef MAGNUM_TARGET_GLES2
.addSource(flags >= Flag::InstancedObjectId ? "#define INSTANCED_OBJECT_ID\n" : "")
#endif
Shaders: implement instancing in Phong.
6 years ago
.addSource(flags & Flag::InstancedTransformation ? "#define INSTANCED_TRANSFORMATION\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
.addSource(flags >= Flag::InstancedTextureOffset ? "#define INSTANCED_TEXTURE_OFFSET\n" : "");
Shaders: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flags >= Flag::UniformBuffers) {
vert.addSource(Utility::formatString(
"#define UNIFORM_BUFFERS\n"
"#define DRAW_COUNT {}\n"
"#define LIGHT_COUNT {}\n",
drawCount,
lightCount));
Shaders: multidraw support in all builtin shaders.
5 years ago
vert.addSource(flags >= Flag::MultiDraw ? "#define MULTI_DRAW\n" : "");
Shaders: add UBO support to all shaders.
5 years ago
}
#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
#ifndef MAGNUM_TARGET_GLES
Shaders: add UBO support to all shaders.
5 years ago
if(!(flags >= Flag::UniformBuffers) && lightCount)
vert.addSource(std::move(lightInitializerVertex));
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
#endif
vert.addSource(rs.get("generic.glsl"))
Reworked and cleaned up shader classes. Removed unneeded member variables, removed wrong assertions and wrong documentation (most of the state they were fobidding is actually valid). Retrieving shader log with full length, properly printing non-error messages to debug output. Each shader must now be compiled explicitly using compile(), which is slightly better for the user as it is possible to check compile status instead of having it weirdly hidden inside attachShader(). link() now also returns linking status.
13 years ago
.addSource(rs.get("Phong.vert"));
Shaders: ambient, diffuse and specular texture support in Phong.
13 years ago
frag.addSource(flags & Flag::AmbientTexture ? "#define AMBIENT_TEXTURE\n" : "")
.addSource(flags & Flag::DiffuseTexture ? "#define DIFFUSE_TEXTURE\n" : "")
.addSource(flags & Flag::SpecularTexture ? "#define SPECULAR_TEXTURE\n" : "")
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
.addSource(flags & Flag::NormalTexture ? "#define NORMAL_TEXTURE\n" : "")
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
.addSource(flags & Flag::TextureArrays ? "#define TEXTURE_ARRAYS\n" : "")
#endif
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
.addSource(flags & Flag::Bitangent ? "#define BITANGENT\n" : "")
Shaders: vertex color support in Phong and Flat.
7 years ago
.addSource(flags & Flag::VertexColor ? "#define VERTEX_COLOR\n" : "")
Shaders: classical alpha masking support in Phong and Flat. Slow and ugly, is here only for making quick'n'dirty alpha masked drawing without a need for blending or depth sorting. Oh and also to support the glTF alpha mask feature. Again, beware: *slow*.
8 years ago
.addSource(flags & Flag::AlphaMask ? "#define ALPHA_MASK\n" : "")
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
.addSource(flags & Flag::ObjectId ? "#define OBJECT_ID\n" : "")
Shaders: ability to render instanced object ID in Flat/Phong.
6 years ago
.addSource(flags >= Flag::InstancedObjectId ? "#define INSTANCED_OBJECT_ID\n" : "")
Shaders: support object ID output in Flat and Phong.
7 years ago
#endif
Shaders: add UBO support to all shaders.
5 years ago
;
#ifndef MAGNUM_TARGET_GLES2
if(flags >= Flag::UniformBuffers) {
frag.addSource(Utility::formatString(
"#define UNIFORM_BUFFERS\n"
"#define DRAW_COUNT {}\n"
"#define MATERIAL_COUNT {}\n"
"#define LIGHT_COUNT {}\n",
drawCount,
materialCount,
lightCount));
Shaders: multidraw support in all builtin shaders.
5 years ago
frag.addSource(flags >= Flag::MultiDraw ? "#define MULTI_DRAW\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",
lightCount,
_lightPositionsUniform + lightCount,
Shaders: add an ability to control specular light color to Phong.
6 years ago
_lightPositionsUniform + 2*lightCount,
_lightPositionsUniform + 3*lightCount));
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: add UBO support to all shaders.
5 years ago
if(!(flags >= Flag::UniformBuffers) && lightCount)
frag.addSource(std::move(lightInitializerFragment));
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
frag.addSource(rs.get("generic.glsl"))
Reworked and cleaned up shader classes. Removed unneeded member variables, removed wrong assertions and wrong documentation (most of the state they were fobidding is actually valid). Retrieving shader log with full length, properly printing non-error messages to debug output. Each shader must now be compiled explicitly using compile(), which is slightly better for the user as it is possible to check compile status instead of having it weirdly hidden inside attachShader(). link() now also returns linking status.
13 years ago
.addSource(rs.get("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
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(GL::Shader::compile({vert, 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: using attachShaders() everywhere.
12 years ago
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
{
Type-checked vertex attributes with type conversion possibility. * Normalization of e.g. color components passed as unsigned byte to float values is possible. * BGRA vector component ordering is possible. * Proper type checking, allowing only GLSL-equivalent types to be used as attributes. * Reverted back to typedef'ing shader attributes, as type conversion can now be specified in constructor.
14 years ago
bindAttributeLocation(Position::Location, "position");
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)
bindAttributeLocation(Normal::Location, "normal");
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
if((flags & Flag::NormalTexture) && lightCount) {
Shaders: fix setup of the tangent attribute on ES2. Yay tests!
7 years ago
bindAttributeLocation(Tangent::Location, "tangent");
Shaders: properly use bitangents in Phong normal map calculation.
6 years ago
if(flags & Flag::Bitangent)
bindAttributeLocation(Bitangent::Location, "bitangent");
}
Shaders: vertex color support in Phong and Flat.
7 years ago
if(flags & Flag::VertexColor)
bindAttributeLocation(Color3::Location, "vertexColor"); /* Color4 is the same */
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
if(flags & (Flag::AmbientTexture|Flag::DiffuseTexture|Flag::SpecularTexture))
bindAttributeLocation(TextureCoordinates::Location, "textureCoordinates");
Shaders: support object ID output in Flat and Phong.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flags & Flag::ObjectId) {
bindFragmentDataLocation(ColorOutput, "color");
bindFragmentDataLocation(ObjectIdOutput, "objectId");
}
Shaders: ability to render instanced object ID in Flat/Phong.
6 years ago
if(flags >= Flag::InstancedObjectId)
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: implement instancing in Phong.
6 years ago
if(flags & Flag::InstancedTransformation)
bindAttributeLocation(TransformationMatrix::Location, "instancedTransformationMatrix");
if(flags >= Flag::InstancedTextureOffset)
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
Reworked and cleaned up shader classes. Removed unneeded member variables, removed wrong assertions and wrong documentation (most of the state they were fobidding is actually valid). Retrieving shader log with full length, properly printing non-error messages to debug output. Each shader must now be compiled explicitly using compile(), which is slightly better for the user as it is possible to check compile status instead of having it weirdly hidden inside attachShader(). link() now also returns linking status.
13 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
New library with sample shaders, currently only Phong shader.
14 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: 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_uniform_location>(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: add UBO support to all shaders.
5 years ago
if(flags >= Flag::UniformBuffers) {
_drawOffsetUniform = uniformLocation("drawOffset");
} 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");
if(flags & Flag::TextureTransformation)
_textureMatrixUniform = uniformLocation("textureMatrix");
Shaders: support array textures in Flat and Phong.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
if(flags & Flag::TextureArrays)
_textureLayerUniform = uniformLocation("textureLayer");
#endif
Shaders: add UBO support to all shaders.
5 years ago
_projectionMatrixUniform = uniformLocation("projectionMatrix");
_ambientColorUniform = uniformLocation("ambientColor");
if(lightCount) {
_normalMatrixUniform = uniformLocation("normalMatrix");
_diffuseColorUniform = uniformLocation("diffuseColor");
_specularColorUniform = uniformLocation("specularColor");
_shininessUniform = uniformLocation("shininess");
if(flags & Flag::NormalTexture)
_normalTextureScaleUniform = uniformLocation("normalTextureScale");
_lightPositionsUniform = uniformLocation("lightPositions");
_lightColorsUniform = uniformLocation("lightColors");
_lightSpecularColorsUniform = uniformLocation("lightSpecularColors");
_lightRangesUniform = uniformLocation("lightRanges");
}
if(flags & Flag::AlphaMask) _alphaMaskUniform = uniformLocation("alphaMask");
#ifndef MAGNUM_TARGET_GLES2
if(flags & Flag::ObjectId) _objectIdUniform = uniformLocation("objectId");
#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: avoid repeated GL::Context::current() calls. It involves a TLS lookup each time and it's just unnecessary extra typing.
5 years ago
if(flags && !context.isExtensionSupported<GL::Extensions::ARB::shading_language_420pack>(version))
Shaders: ambient, diffuse and specular texture support in Phong.
13 years ago
#endif
{
Shaders: NO, these are not layers.
6 years ago
if(flags & Flag::AmbientTexture) setUniform(uniformLocation("ambientTexture"), AmbientTextureUnit);
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) {
Shaders: NO, these are not layers.
6 years ago
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
if(flags >= Flag::UniformBuffers) {
setUniformBlockBinding(uniformBlockIndex("Projection"), ProjectionBufferBinding);
setUniformBlockBinding(uniformBlockIndex("Transformation"), TransformationBufferBinding);
setUniformBlockBinding(uniformBlockIndex("Draw"), DrawBufferBinding);
setUniformBlockBinding(uniformBlockIndex("Material"), MaterialBufferBinding);
if(flags & Flag::TextureTransformation)
setUniformBlockBinding(uniformBlockIndex("TextureTransformation"), TextureTransformationBufferBinding);
if(lightCount)
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
if(flags >= Flag::UniformBuffers) {
/* Draw offset is zero by default */
} else
#endif
{
/* Default to fully opaque white so we can see the textures */
if(flags & Flag::AmbientTexture) setAmbientColor(Magnum::Color4{1.0f});
else setAmbientColor(Magnum::Color4{0.0f});
setTransformationMatrix(Matrix4{Math::IdentityInit});
setProjectionMatrix(Matrix4{Math::IdentityInit});
if(lightCount) {
setDiffuseColor(Magnum::Color4{1.0f});
setSpecularColor(Magnum::Color4{1.0f, 0.0f});
setShininess(80.0f);
if(flags & Flag::NormalTexture)
setNormalTextureScale(1.0f);
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}};
setLightColors(colors);
setLightSpecularColors(colors);
setLightRanges(Containers::Array<Float>{DirectInit, lightCount, Constants::inf()});
/* Light position is zero by default */
setNormalMatrix(Matrix3x3{Math::IdentityInit});
}
if(flags & Flag::TextureTransformation)
setTextureMatrix(Matrix3{Math::IdentityInit});
Shaders: support array textures in Flat and Phong.
5 years ago
/* Texture layer is zero by default */
Shaders: add UBO support to all shaders.
5 years ago
if(flags & Flag::AlphaMask) setAlphaMask(0.5f);
/* 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: add UBO support to all shaders.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
PhongGL::PhongGL(const Flags flags, const UnsignedInt lightCount): PhongGL{flags, lightCount, 1, 1} {}
#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: 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: 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: 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: 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);
setUniform(_drawOffsetUniform, offset);
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
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) {
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
Shaders: ability to render instanced object ID in Flat/Phong.
6 years ago
_c(InstancedObjectId)
Shaders: support object ID output in Flat and Phong.
7 years ago
_c(ObjectId)
#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: add UBO support to all shaders.
5 years ago
#endif
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
#undef _c
/* LCOV_EXCL_STOP */
}
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
return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(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: 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 */
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,
PhongGL::Flag::TextureArrays
Shaders: add UBO support to all shaders.
5 years ago
#endif
});
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
}}