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

492 lines
21 KiB
Raw Normal View History Unescape

Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 years ago
/*
This file is part of Magnum.
Updated copyright year.
7 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019
Happy new year too.
12 years ago
Vladimír Vondruš <mosra@centrum.cz>
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
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.
*/
#include "MeshVisualizer.h"
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
#include <Corrade/Containers/EnumSet.hpp>
Use privately Corrade Optional instead of the problematic std::optional. Not in the public APIs yet (Trade etc.), as I need to solve backwards compatibility first.
8 years ago
#include <Corrade/Containers/Optional.h>
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: tangent space visualization in MeshVisualizer3D.
6 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>
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 years ago
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
#include "Magnum/Math/Color.h"
Shaders: add a 2D variant of MeshVisualizer.
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"
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"
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 years ago
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
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 years ago
namespace Magnum { namespace Shaders {
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
namespace Implementation {
MeshVisualizerBase::MeshVisualizerBase(FlagsBase flags): _flags{flags} {
Shaders: ported MeshVisualizer to use geometry shaders also on ES3+AEP. Please note that in ES3 there is a behavioral change -- geometry shader is no longer explicitly disabled, but it is enabled by default and you have to disable it if you don't have the required extension or don't want to use it.
11 years ago
#ifndef MAGNUM_TARGET_GLES2
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
if(_flags & FlagBase::Wireframe && !(_flags & FlagBase::NoGeometryShader)) {
Shaders: ported MeshVisualizer to use geometry shaders also on ES3+AEP. Please note that in ES3 there is a behavioral change -- geometry shader is no longer explicitly disabled, but it is enabled by default and you have to disable it if you don't have the required extension or don't want to use it.
11 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
MAGNUM_ASSERT_GL_VERSION_SUPPORTED(GL::Version::GL320);
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::ARB::geometry_shader4);
Shaders: fix WebGL 2 compilation. This is starting to be a little annoying.
11 years ago
#elif !defined(MAGNUM_TARGET_WEBGL)
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::EXT::geometry_shader);
Shaders: ported MeshVisualizer to use geometry shaders also on ES3+AEP. Please note that in ES3 there is a behavioral change -- geometry shader is no longer explicitly disabled, but it is enabled by default and you have to disable it if you don't have the required extension or don't want to use it.
11 years ago
#endif
Shaders: extension queries depending on GLSL version in MeshVisualizer. The geometry shader implementation somehow expects GLSL 1.50 and is not working on GLSL 1.40 (probably inconsistent variable naming in extension and core specification). Added checks for that. Might fix this properly someday when there is need for geometry shader in GL 3.1.
13 years ago
}
Shaders: ported MeshVisualizer to use geometry shaders also on ES3+AEP. Please note that in ES3 there is a behavioral change -- geometry shader is no longer explicitly disabled, but it is enabled by default and you have to disable it if you don't have the required extension or don't want to use it.
11 years ago
#else
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
if(_flags & FlagBase::Wireframe)
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::OES::standard_derivatives);
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
#endif
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 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 */
if(!Utility::Resource::hasGroup("MagnumShaders"))
importShaderResources();
#endif
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
}
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 years ago
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
GL::Version MeshVisualizerBase::setupShaders(GL::Shader& vert, GL::Shader& frag, const Utility::Resource& rs) const {
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
const GL::Version version = GL::Context::current().supportedVersion({GL::Version::GL320, GL::Version::GL310, GL::Version::GL300, GL::Version::GL210});
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
CORRADE_INTERNAL_ASSERT(!_flags || _flags & FlagBase::NoGeometryShader || version >= GL::Version::GL320);
Shaders: fix MeshVisualizer compilation on WebGL.
11 years ago
#elif !defined(MAGNUM_TARGET_WEBGL)
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
const GL::Version version = GL::Context::current().supportedVersion({GL::Version::GLES310, GL::Version::GLES300, GL::Version::GLES200});
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
CORRADE_INTERNAL_ASSERT(!_flags || _flags & FlagBase::NoGeometryShader || version >= GL::Version::GLES310);
Shaders: fix MeshVisualizer compilation on WebGL.
11 years ago
#else
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
const GL::Version version = GL::Context::current().supportedVersion({GL::Version::GLES300, GL::Version::GLES200});
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
#endif
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
vert = Implementation::createCompatibilityShader(rs, version, GL::Shader::Type::Vertex);
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: add a 2D variant of MeshVisualizer.
6 years ago
vert.addSource(_flags & FlagBase::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
.addSource(_flags & FlagBase::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
Shaders: fix compilation of MeshVisualizer on WebGL and ANGLE. WebGL mandates that array subscription is done with constant expression, ANGLE too (but I think that has also something to do with D3D9 limitations). This is however allowed by OpenGL ES 2.0 specification, so enabling the workaround only for WebGL and ANGLE (i.e., this won't apply to Native Client using native GL drivers).
12 years ago
#ifdef MAGNUM_TARGET_WEBGL
.addSource("#define SUBSCRIPTING_WORKAROUND\n")
Shaders: fix build on ES3. I'm starting to hate these rushed prerelease fixes.
12 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
.addSource(GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::Angle ?
Shaders: fix compilation of MeshVisualizer on WebGL and ANGLE. WebGL mandates that array subscription is done with constant expression, ANGLE too (but I think that has also something to do with D3D9 limitations). This is however allowed by OpenGL ES 2.0 specification, so enabling the workaround only for WebGL and ANGLE (i.e., this won't apply to Native Client using native GL drivers).
12 years ago
"#define SUBSCRIPTING_WORKAROUND\n" : "")
#endif
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
;
frag.addSource(_flags & FlagBase::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
.addSource(_flags & FlagBase::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "");
return version;
}
MeshVisualizerBase& MeshVisualizerBase::setColor(const Color4& color) {
setUniform(_colorUniform, color);
return *this;
}
MeshVisualizerBase& MeshVisualizerBase::setWireframeColor(const Color4& color) {
CORRADE_ASSERT(_flags & FlagBase::Wireframe,
"Shaders::MeshVisualizer::setWireframeColor(): the shader was not created with wireframe enabled", *this);
setUniform(_wireframeColorUniform, color);
return *this;
}
MeshVisualizerBase& MeshVisualizerBase::setWireframeWidth(const Float width) {
CORRADE_ASSERT(_flags & FlagBase::Wireframe,
"Shaders::MeshVisualizer::setWireframeWidth(): the shader was not created with wireframe enabled", *this);
setUniform(_wireframeWidthUniform, width);
return *this;
}
}
MeshVisualizer2D::MeshVisualizer2D(const Flags flags): Implementation::MeshVisualizerBase{Implementation::MeshVisualizerBase::FlagBase(UnsignedByte(flags))} {
Utility::Resource rs{"MagnumShaders"};
GL::Shader vert{NoCreate};
GL::Shader frag{NoCreate};
const GL::Version version = setupShaders(vert, frag, rs);
vert.addSource("#define TWO_DIMENSIONS\n")
Shaders: use generic definitions also in GLSL sources. So each sourcs doesn't need to be manually rewritten each time the generic definition changes.
13 years ago
.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("MeshVisualizer.vert"));
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
frag.addSource(rs.get("generic.glsl"))
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
.addSource(rs.get("MeshVisualizer.frag"));
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 years ago
Shaders: fix WebGL 2 compilation. This is starting to be a little annoying.
11 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
Containers::Optional<GL::Shader> geom;
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
if(flags & Flag::Wireframe && !(flags & Flag::NoGeometryShader)) {
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
geom = Implementation::createCompatibilityShader(rs, version, GL::Shader::Type::Geometry);
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
(*geom)
.addSource("#define WIREFRAME_RENDERING\n#define MAX_VERTICES 3\n")
.addSource(rs.get("MeshVisualizer.geom"));
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
}
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
#else
static_cast<void>(version);
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
#endif
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 years ago
Shaders: one more try.
11 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
if(geom) CORRADE_INTERNAL_ASSERT_OUTPUT(GL::Shader::compile({vert, *geom, 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
else
#endif
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});
Shaders: one more try.
11 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
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
if(geom) attachShader(*geom);
#endif
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 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
/* ES3 has this done in the shader directly */
#if !defined(MAGNUM_TARGET_GLES) || defined(MAGNUM_TARGET_GLES2)
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::explicit_attrib_location>(version))
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
#endif
{
bindAttributeLocation(Position::Location, "position");
Shaders: use Context::isVersionSupported() instead of ad-hoc solution. Also removed redundant branching for ES.
13 years ago
Shaders: gl_VertexID is supported in GLES 3.0.
11 years ago
#if !defined(MAGNUM_TARGET_GLES) || defined(MAGNUM_TARGET_GLES2)
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
if(!GL::Context::current().isVersionSupported(GL::Version::GL310))
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
#endif
Shaders: use Context::isVersionSupported() instead of ad-hoc solution. Also removed redundant branching for ES.
13 years ago
{
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
bindAttributeLocation(VertexIndex::Location, "vertexIndex");
Shaders: use Context::isVersionSupported() instead of ad-hoc solution. Also removed redundant branching for ES.
13 years ago
}
Shaders: gl_VertexID is supported in GLES 3.0.
11 years ago
#endif
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 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
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 20: adapted Shaders.
8 years ago
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::explicit_uniform_location>(version))
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
#endif
{
Shaders: modernize coding style. * Always prefix private members with an underscore * Use in-class initialization of the uniform locations * Use {} for default flag value
9 years ago
_transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
_colorUniform = uniformLocation("color");
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
if(flags & Flag::Wireframe) {
Shaders: modernize coding style. * Always prefix private members with an underscore * Use in-class initialization of the uniform locations * Use {} for default flag value
9 years ago
_wireframeColorUniform = uniformLocation("wireframeColor");
_wireframeWidthUniform = uniformLocation("wireframeWidth");
_smoothnessUniform = uniformLocation("smoothness");
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
if(!(flags & Flag::NoGeometryShader))
Shaders: modernize coding style. * Always prefix private members with an underscore * Use in-class initialization of the uniform locations * Use {} for default flag value
9 years ago
_viewportSizeUniform = uniformLocation("viewportSize");
Shaders: ported MeshVisualizer to not require geometry shader. Wireframe width and smoothness isn't ported yet, because I don't fully understand the behavior of standard derivatives in fragment shader.
13 years ago
}
}
Shaders: really ported MeshVisualizer to ES.
13 years ago
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
Shaders: define reasonable uniform defaults for all shaders. Plus a bit of cleanup / fixing broken English.
8 years ago
setTransformationProjectionMatrix({});
Getting rid of <>, part 1: Color classes. Inspired in STL, base templated class is renamed to BasicColor{3,4} and typedef'd with Float type to Color{3, 4}. It is much nicer to write this: Color3(1.0f) Color3::fromHSV(25.0_degf, 0.5f, 0.9f); instead of this: Color3<>(1.0f); Color3<>::fromHSV(25.0_degf, 0.5f, 0.9f);
13 years ago
setColor(Color3(1.0f));
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
if(flags & Flag::Wireframe) {
Shaders: define reasonable uniform defaults for all shaders. Plus a bit of cleanup / fixing broken English.
8 years ago
/* Viewport size is zero by default */
setWireframeColor(Color3{0.0f});
Shaders: really ported MeshVisualizer to ES.
13 years ago
setWireframeWidth(1.0f);
setSmoothness(2.0f);
}
#endif
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 years ago
}
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
MeshVisualizer2D& MeshVisualizer2D::setViewportSize(const Vector2& size) {
/* Not asserting here, since the relation to wireframe is a bit vague.
Also it's an ugly hack that should be removed, ideally. */
if(flags() & Flag::Wireframe && !(flags() & Flag::NoGeometryShader))
setUniform(_viewportSizeUniform, size);
return *this;
}
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
MeshVisualizer2D& MeshVisualizer2D::setTransformationProjectionMatrix(const Matrix3& matrix) {
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
setUniform(_transformationProjectionMatrixUniform, matrix);
return *this;
}
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
MeshVisualizer2D& MeshVisualizer2D::setSmoothness(const Float smoothness) {
/* This is a bit vaguely related but less vague than setViewportSize() so
asserting in this case. */
CORRADE_ASSERT(flags() & Flag::Wireframe,
"Shaders::MeshVisualizer2D::setSmoothness(): the shader was not created with wireframe enabled", *this);
setUniform(_smoothnessUniform, smoothness);
return *this;
}
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
MeshVisualizer3D::MeshVisualizer3D(const Flags flags): Implementation::MeshVisualizerBase{Implementation::MeshVisualizerBase::FlagBase(UnsignedByte(flags))} {
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
CORRADE_ASSERT(!(flags & Flag::NoGeometryShader && flags & (Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection)),
"Shaders::MeshVisualizer3D: geometry shader has to be enabled when rendering TBN direction", );
CORRADE_ASSERT(!(flags & Flag::BitangentDirection && flags & Flag::BitangentFromTangentDirection),
"Shaders::MeshVisualizer3D: Flag::BitangentDirection and Flag::BitangentFromTangentDirection are mutually exclusive", );
#endif
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
Utility::Resource rs{"MagnumShaders"};
GL::Shader vert{NoCreate};
GL::Shader frag{NoCreate};
const GL::Version version = setupShaders(vert, frag, rs);
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
vert.addSource("#define THREE_DIMENSIONS\n")
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
.addSource(flags & Flag::TangentDirection ? "#define TANGENT_DIRECTION\n" : "")
.addSource(flags & Flag::BitangentFromTangentDirection ? "#define BITANGENT_FROM_TANGENT_DIRECTION\n" : "")
.addSource(flags & Flag::BitangentDirection ? "#define BITANGENT_DIRECTION\n" : "")
.addSource(flags & Flag::NormalDirection ? "#define NORMAL_DIRECTION\n" : "")
#endif
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
.addSource(rs.get("generic.glsl"))
.addSource(rs.get("MeshVisualizer.vert"));
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
frag
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
.addSource(flags & (Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection) ? "#define TBN_DIRECTION\n" : "")
#endif
.addSource(rs.get("generic.glsl"))
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
.addSource(rs.get("MeshVisualizer.frag"));
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
Containers::Optional<GL::Shader> geom;
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
if(flags & (Flag::Wireframe|Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection) && !(flags & Flag::NoGeometryShader)) {
Int maxVertices = 0;
if(flags & Flag::Wireframe) maxVertices += 3;
if(flags & Flag::TangentDirection) maxVertices += 3*6;
if(flags & (Flag::BitangentDirection|Flag::BitangentFromTangentDirection))
maxVertices += 3*6;
if(flags & Flag::NormalDirection) maxVertices += 3*6;
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
geom = Implementation::createCompatibilityShader(rs, version, GL::Shader::Type::Geometry);
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
(*geom)
.addSource(Utility::formatString("#define MAX_VERTICES {}\n", maxVertices))
.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
.addSource(flags & Flag::TangentDirection ? "#define TANGENT_DIRECTION\n" : "")
.addSource(flags & (Flag::BitangentDirection|Flag::BitangentFromTangentDirection) ? "#define BITANGENT_DIRECTION\n" : "")
.addSource(flags & Flag::NormalDirection ? "#define NORMAL_DIRECTION\n" : "")
.addSource(rs.get("MeshVisualizer.geom"));
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
}
#else
static_cast<void>(version);
#endif
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(geom) CORRADE_INTERNAL_ASSERT_OUTPUT(GL::Shader::compile({vert, *geom, frag}));
else
#endif
CORRADE_INTERNAL_ASSERT_OUTPUT(GL::Shader::compile({vert, frag}));
attachShaders({vert, frag});
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(geom) attachShader(*geom);
#endif
/* ES3 has this done in the shader directly */
#if !defined(MAGNUM_TARGET_GLES) || defined(MAGNUM_TARGET_GLES2)
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::explicit_attrib_location>(version))
#endif
{
bindAttributeLocation(Position::Location, "position");
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(flags & Flag::TangentDirection ||
flags & Flag::BitangentFromTangentDirection)
bindAttributeLocation(Tangent4::Location, "tangent");
if(flags & Flag::BitangentDirection)
bindAttributeLocation(Bitangent::Location, "bitangent");
if(flags & Flag::NormalDirection ||
flags & Flag::BitangentFromTangentDirection)
bindAttributeLocation(Normal::Location, "normal");
#endif
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
#if !defined(MAGNUM_TARGET_GLES) || defined(MAGNUM_TARGET_GLES2)
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isVersionSupported(GL::Version::GL310))
#endif
{
bindAttributeLocation(VertexIndex::Location, "vertexIndex");
}
#endif
}
#endif
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::explicit_uniform_location>(version))
#endif
{
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
_transformationMatrixUniform = uniformLocation("transformationMatrix");
_projectionMatrixUniform = uniformLocation("projectionMatrix");
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
_colorUniform = uniformLocation("color");
if(flags & Flag::Wireframe) {
_wireframeColorUniform = uniformLocation("wireframeColor");
_wireframeWidthUniform = uniformLocation("wireframeWidth");
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
}
if(flags & (Flag::Wireframe
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
|Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection
#endif
)) {
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
_smoothnessUniform = uniformLocation("smoothness");
if(!(flags & Flag::NoGeometryShader))
_viewportSizeUniform = uniformLocation("viewportSize");
}
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(flags & (Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection)) {
_normalMatrixUniform = uniformLocation("normalMatrix");
_lineWidthUniform = uniformLocation("lineWidth");
_lineLengthUniform = uniformLocation("lineLength");
}
#endif
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
}
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
setTransformationMatrix({});
setProjectionMatrix({});
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
setColor(Color3(1.0f));
if(flags & Flag::Wireframe) {
/* Viewport size is zero by default */
setWireframeColor(Color3{0.0f});
setWireframeWidth(1.0f);
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
}
if(flags & (Flag::Wireframe
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
|Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection
#endif
)) {
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
setSmoothness(2.0f);
}
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(flags & (Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection)) {
setNormalMatrix({});
setLineWidth(1.0f);
setLineLength(1.0f);
}
#endif
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
#endif
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
}
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
MeshVisualizer3D& MeshVisualizer3D::setTransformationMatrix(const Matrix4& matrix) {
setUniform(_transformationMatrixUniform, matrix);
return *this;
}
MeshVisualizer3D& MeshVisualizer3D::setProjectionMatrix(const Matrix4& matrix) {
setUniform(_projectionMatrixUniform, matrix);
return *this;
}
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
MeshVisualizer3D& MeshVisualizer3D::setNormalMatrix(const Matrix3x3& matrix) {
CORRADE_ASSERT(flags() & (Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection),
"Shaders::MeshVisualizer3D::setNormalMatrix(): the shader was not created with TBN direction enabled", *this);
setUniform(_normalMatrixUniform, matrix);
return *this;
}
#endif
MeshVisualizer3D& MeshVisualizer3D::setViewportSize(const Vector2& size) {
/* Not asserting here, since the relation to wireframe is a bit vague.
Also it's an ugly hack that should be removed, ideally. */
if((flags() & Flag::Wireframe && !(flags() & Flag::NoGeometryShader))
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
|| flags() & (Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection)
#endif
)
setUniform(_viewportSizeUniform, size);
return *this;
}
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
MeshVisualizer3D& MeshVisualizer3D::setLineWidth(const Float width) {
CORRADE_ASSERT(flags() & (Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection),
"Shaders::MeshVisualizer3D::setLineWidth(): the shader was not created with TBN direction enabled", *this);
setUniform(_lineWidthUniform, width);
return *this;
}
MeshVisualizer3D& MeshVisualizer3D::setLineLength(const Float length) {
CORRADE_ASSERT(flags() & (Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection),
"Shaders::MeshVisualizer3D::setLineLength(): the shader was not created with TBN direction enabled", *this);
setUniform(_lineLengthUniform, length);
return *this;
}
#endif
MeshVisualizer3D& MeshVisualizer3D::setSmoothness(const Float smoothness) {
#ifndef CORRADE_NO_ASSERT
/* This is a bit vaguely related but less vague than setViewportSize() so
asserting in this case. */
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
constexpr Flags allowed = Flag::Wireframe|Flag::TangentDirection|Flag::BitangentFromTangentDirection|Flag::BitangentDirection|Flag::NormalDirection;
#else
constexpr Flags allowed = Flag::Wireframe;
#endif
CORRADE_ASSERT(flags() & allowed,
"Shaders::MeshVisualizer3D::setSmoothness(): the shader was not created with wireframe or TBN direction enabled", *this);
#endif
setUniform(_smoothnessUniform, smoothness);
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
return *this;
}
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
Debug& operator<<(Debug& debug, const MeshVisualizer2D::Flag value) {
debug << "Shaders::MeshVisualizer2D::Flag" << Debug::nospace;
switch(value) {
/* LCOV_EXCL_START */
#define _c(v) case MeshVisualizer2D::Flag::v: return debug << "::" #v;
_c(NoGeometryShader)
_c(Wireframe)
#undef _c
/* LCOV_EXCL_STOP */
}
return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(value)) << Debug::nospace << ")";
Shaders: de-inline uniform setters. Reduces includes in the header quite a lot, yay.
7 years ago
}
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
Debug& operator<<(Debug& debug, const MeshVisualizer3D::Flag value) {
debug << "Shaders::MeshVisualizer3D::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: add a 2D variant of MeshVisualizer.
6 years ago
#define _c(v) case MeshVisualizer3D::Flag::v: return debug << "::" #v;
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
_c(NoGeometryShader)
_c(Wireframe)
Shaders: tangent space visualization in MeshVisualizer3D.
6 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
_c(TangentDirection)
_c(BitangentFromTangentDirection)
_c(BitangentDirection)
_c(NormalDirection)
#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: add a 2D variant of MeshVisualizer.
6 years ago
Debug& operator<<(Debug& debug, const MeshVisualizer2D::Flags value) {
return Containers::enumSetDebugOutput(debug, value, "Shaders::MeshVisualizer2D::Flags{}", {
MeshVisualizer2D::Flag::Wireframe,
/* Wireframe contains this on ES2 so it's not reported there */
MeshVisualizer2D::Flag::NoGeometryShader
});
}
Debug& operator<<(Debug& debug, const MeshVisualizer3D::Flags value) {
return Containers::enumSetDebugOutput(debug, value, "Shaders::MeshVisualizer3D::Flags{}", {
MeshVisualizer3D::Flag::Wireframe,
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
/* Wireframe contains this on ES2 so it's not reported there */
Shaders: add a 2D variant of MeshVisualizer.
6 years ago
MeshVisualizer3D::Flag::NoGeometryShader
Shaders: debug output for all Flag / Flags enums / enum sets.
8 years ago
});
}
Shaders: added first version of MeshVisualizer shader. Rudely written to work only with fairly recent extensions and nothing less than GLSL 3.30. It requires geometry shaders for wireframe rendering, without it it behaves the same as Shaders::Flat.
13 years ago
}}