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.
10807 Commits
21 Branches
19 Tags
70 MiB
Tree: 8f6f4053fc
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8f6f4053fc'
${ noResults }
magnum/src/Magnum/TextureTools/DistanceField.cpp

235 lines
8.1 KiB
Raw Normal View History Unescape

TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
/*
This file is part of Magnum.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
It's 2023 already!
3 years ago
2020, 2021, 2022, 2023 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.
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
*/
Making includes absolute, part 5: absolute includes everywhere. The only places where they aren't absolute are: - when header is included from corresponding source file - when including headers which are not part of final installation (e.g. test-specific configuration, headers from Implementation/)
13 years ago
#include "DistanceField.h"
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
GL: take an Iterable in AbstractShaderProgram::attachShaders(). Consistently with checkLink(), this avoids having to explicitly include both Iterable and Reference in shader code. Alsod allowing people to have direct arrays of shaders, runtime-sized lists of shaders etc. A compat include is provided on a deprecated build to avoid breaking existing code.
4 years ago
#include <Corrade/Containers/Iterable.h>
GL: port Shader and ShaderProgram away from std::string. Same as in the previous commit, most cases are inputs so a StringStl.h compatibility include will do, the only breaking change is GL::Shader::sources() which now returns a StringIterable instead of a std::vector<std::string> (ew). Awesome about this whole thing is that The Shader API now allows creating a shader from sources coming either from string view literals or Utility::Resource completely without having to allocate any strings internally, because all those can be just non-owning references wrapped with String::nullTerminatedGlobalView(). The only parts which aren't references are the #line markers, but (especially on 64bit) those can easily fit into the 22-byte (or 10-byte on 32bit) SSO storage. Also, various Shader constructors and assignment operators had to be deinlined in order to avoid having to include the String header, which would be needed for Array destruction during a move. Co-authored-by: Hugo Amiard <hugo.amiard@wonderlandengine.com>
3 years ago
#include <Corrade/Containers/String.h>
#include <Corrade/Utility/Format.h>
Making includes absolute, part 4: using absolute includes for Corrade. Also adapted to some Corrade renames.
13 years ago
#include <Corrade/Utility/Resource.h>
Extract Buffer::Usage enum out of Buffer class. Buffer usage is used as parameter in many functions, e.g. in *Framebuffer::read() and *Texture::image(), but they are rather seldom used and including whole Buffer.h file just for one enum is just overkill. The old Buffer::Usage is now alias to BufferUsage, it is marked as deprecated and will be removed in future release.
13 years ago
Making includes absolute, part 5: absolute includes everywhere. The only places where they aren't absolute are: - when header is included from corresponding source file - when including headers which are not part of final installation (e.g. test-specific configuration, headers from Implementation/)
13 years ago
#include "Magnum/Math/Range.h"
Split the OpenGL layer out, pt 19: adapted TextureTools.
8 years ago
#include "Magnum/GL/AbstractShaderProgram.h"
#include "Magnum/GL/Buffer.h"
#include "Magnum/GL/Context.h"
#include "Magnum/GL/Extensions.h"
#include "Magnum/GL/Framebuffer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/GL/Shader.h"
#include "Magnum/GL/Texture.h"
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
TextureTools: hide unused function on dynamic build.
11 years ago
#ifdef MAGNUM_BUILD_STATIC
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
static void importTextureToolResources() {
TextureTools: what's up with this arcane naming.
4 years ago
CORRADE_RESOURCE_INITIALIZE(MagnumTextureTools_RESOURCES)
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
}
TextureTools: hide unused function on dynamic build.
11 years ago
#endif
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
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
namespace Magnum { namespace TextureTools {
DebugTools,Shaders,TextureTools: use string view literals everywhere. Mainly important for Shader::addSource() to prevent it from creating a needless copy, but doesn't hurt to do the same also for uniformLocation(), bindAttributeLocation() etc. -- it'll avoid a runtime strlen() in that case at least.
3 years ago
using namespace Containers::Literals;
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
namespace {
Split the OpenGL layer out, pt 19: adapted TextureTools.
8 years ago
class DistanceFieldShader: public GL::AbstractShaderProgram {
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
public:
Split the OpenGL layer out, pt 19: adapted TextureTools.
8 years ago
typedef GL::Attribute<0, Vector2> Position;
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
TextureTools: make distance field processing into a stateful class.
8 years ago
explicit DistanceFieldShader(UnsignedInt radius);
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
Reducing pointer chasings, part 1: method chaining via references. Makes some cases less consistent (and some convenience shortcuts impossible), but goes well with the attitude "don't use pointer when it can't be null".
13 years ago
DistanceFieldShader& setImageSizeInverted(const Vector2& size) {
TextureTools: underscore private variables.
3 years ago
setUniform(_imageSizeInvertedUniform, size);
Reducing pointer chasings, part 1: method chaining via references. Makes some cases less consistent (and some convenience shortcuts impossible), but goes well with the attitude "don't use pointer when it can't be null".
13 years ago
return *this;
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
}
Split the OpenGL layer out, pt 19: adapted TextureTools.
8 years ago
DistanceFieldShader& bindTexture(GL::Texture2D& texture) {
Follow OpenGL terminology for texture binding units. Until now the textures were bound to layers, which was rather confusing, especially when binding layered textures to layers (gaah). Also the wording might have implied that each texture must be in some layer in order to make it usable in shader. This is no longer the case with (yet unimplemented) bindless texture, so another reason to remove the confusion. All occurences of texture layers were replaced texture binding units to follow OpenGL naming. It was mostly in the docs, except for already-deprecated *Layer enums in shaders, but they will be removed soon anyway.
12 years ago
texture.bind(TextureUnit);
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
return *this;
}
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
private:
TextureTools: don't require more than 8 texture units in distanceField(). ES2 contexts on iOS don't have more than that. It's weird, because ES3 contexts have 16.
8 years ago
/* ES2 on iOS (apparently independent on the device) has only 8 texture
Fix DistanceFieldVector on WebGL iOS
7 years ago
units, so be careful to not step over that. ES3 on the same has 16.
Not using the default (0) because this shader is quite specific.
Unit 6 is used by Shaders::Vector and Shaders::DistanceFieldVector. */
TextureTools: don't require more than 8 texture units in distanceField(). ES2 contexts on iOS don't have more than that. It's weird, because ES3 contexts have 16.
8 years ago
enum: Int { TextureUnit = 7 };
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
TextureTools: make DistanceField working with subrectangles. Just cannot use gl_FragCoord in here. That's it, that's the fix. What's however COMPLETELY unexpected is that this simple change made the process significantly faster on my Intel GPU, from ~815 µs to 670! I can't even pretend I understand what's going on here, but maybe doing less math in the fragment shader when calculating the texture coordinates (and thus possibly the driver having a better idea how to prefetch or schedule?) is what made this faster? Or maybe it's due to one uniform input less, and two interpolated values instead of four on the way from the vertex shader?
3 years ago
Int _imageSizeInvertedUniform{0};
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
};
TextureTools: make distance field processing into a stateful class.
8 years ago
DistanceFieldShader::DistanceFieldShader(const UnsignedInt radius) {
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 */
DebugTools,Shaders,TextureTools: use string view literals everywhere. Mainly important for Shader::addSource() to prevent it from creating a needless copy, but doesn't hurt to do the same also for uniformLocation(), bindAttributeLocation() etc. -- it'll avoid a runtime strlen() in that case at least.
3 years ago
if(!Utility::Resource::hasGroup("MagnumTextureTools"_s))
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
importTextureToolResources();
#endif
DebugTools,Shaders,TextureTools: use string view literals everywhere. Mainly important for Shader::addSource() to prevent it from creating a needless copy, but doesn't hurt to do the same also for uniformLocation(), bindAttributeLocation() etc. -- it'll avoid a runtime strlen() in that case at least.
3 years ago
Utility::Resource rs("MagnumTextureTools"_s);
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 19: adapted TextureTools.
8 years ago
const GL::Version v = GL::Context::current().supportedVersion({GL::Version::GL320, GL::Version::GL300, GL::Version::GL210});
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#else
Shaders: don't format & pass _LOCATION defines on ES < 3.1 and WebGL. Saves quite a few unnecessary allocations and string operations.
3 years ago
const GL::Version v = GL::Context::current().supportedVersion({
#ifndef MAGNUM_TARGET_WEBGL
GL::Version::GLES310,
#endif
GL::Version::GLES300, GL::Version::GLES200});
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#endif
Shaders: drop the createCompatibilityShader() helper. With the workarounds moved to the GL::Shader class itself, it's just a complicated wrapper for adding the compatibility.glsl file and a rather strange way to define a file-local helper for resource import on static builds. Do that directly instead.
3 years ago
GL::Shader vert{v, GL::Shader::Type::Vertex};
vert.addSource(rs.getString("compatibility.glsl"_s))
.addSource(rs.getString("FullScreenTriangle.glsl"_s))
DebugTools,Shaders,TextureTools: use string view literals everywhere. Mainly important for Shader::addSource() to prevent it from creating a needless copy, but doesn't hurt to do the same also for uniformLocation(), bindAttributeLocation() etc. -- it'll avoid a runtime strlen() in that case at least.
3 years ago
.addSource(rs.getString("DistanceFieldShader.vert"_s));
Shaders: drop the createCompatibilityShader() helper. With the workarounds moved to the GL::Shader class itself, it's just a complicated wrapper for adding the compatibility.glsl file and a rather strange way to define a file-local helper for resource import on static builds. Do that directly instead.
3 years ago
GL::Shader frag{v, GL::Shader::Type::Fragment};
frag.addSource(rs.getString("compatibility.glsl"_s))
.addSource(Utility::format("#define RADIUS {}\n", radius))
DebugTools,Shaders,TextureTools: use string view literals everywhere. Mainly important for Shader::addSource() to prevent it from creating a needless copy, but doesn't hurt to do the same also for uniformLocation(), bindAttributeLocation() etc. -- it'll avoid a runtime strlen() in that case at least.
3 years ago
.addSource(rs.getString("DistanceFieldShader.frag"_s));
TextureTools: use threaded shader compilation also here.
12 years ago
GL: deprecate list-taking Shader::compile() and ShaderProgram::link(). There's no reason for those to exist anymore -- origiinally they were added in a hopeful attempt to make use of parallel shader compilation, but in practice that meant compiling at most two or three shaders at once and still stalling until that was done, so not that great at all. The new APIs provide much better opportunities for parallelism. Fun fact: CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile() && frag.compile()); is actually one character shorter than CORRADE_INTERNAL_ASSERT_OUTPUT(GL::Shader::compile({vert, frag})); so not even typing convenience would be a reason to keep these.
4 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile() && frag.compile());
TextureTools: use threaded shader compilation also here.
12 years ago
attachShaders({vert, frag});
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
GL: don't include MAGNUM_shader_vertex_id on ES2 builds. It makes one think such feature *could* be supported there, while it couldn't.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
if(!GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
#endif
{
DebugTools,Shaders,TextureTools: use string view literals everywhere. Mainly important for Shader::addSource() to prevent it from creating a needless copy, but doesn't hurt to do the same also for uniformLocation(), bindAttributeLocation() etc. -- it'll avoid a runtime strlen() in that case at least.
3 years ago
bindAttributeLocation(Position::Location, "position"_s);
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 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());
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 19: adapted TextureTools.
8 years ago
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::explicit_uniform_location>())
Shaders: use explicit texture location and binding on ES3.1+. No reason not to, reduces the amount of unnecessary driver calls quite significantly.
3 years ago
#elif !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(v < GL::Version::GLES310)
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#endif
{
TextureTools: make DistanceField working with subrectangles. Just cannot use gl_FragCoord in here. That's it, that's the fix. What's however COMPLETELY unexpected is that this simple change made the process significantly faster on my Intel GPU, from ~815 µs to 670! I can't even pretend I understand what's going on here, but maybe doing less math in the fragment shader when calculating the texture coordinates (and thus possibly the driver having a better idea how to prefetch or schedule?) is what made this faster? Or maybe it's due to one uniform input less, and two interpolated values instead of four on the way from the vertex shader?
3 years ago
_imageSizeInvertedUniform = uniformLocation("imageSizeInverted"_s);
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
}
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 19: adapted TextureTools.
8 years ago
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::shading_language_420pack>())
Shaders: use explicit texture location and binding on ES3.1+. No reason not to, reduces the amount of unnecessary driver calls quite significantly.
3 years ago
#elif !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
if(v < GL::Version::GLES310)
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#endif
{
DebugTools,Shaders,TextureTools: use string view literals everywhere. Mainly important for Shader::addSource() to prevent it from creating a needless copy, but doesn't hurt to do the same also for uniformLocation(), bindAttributeLocation() etc. -- it'll avoid a runtime strlen() in that case at least.
3 years ago
setUniform(uniformLocation("textureData"_s), TextureUnit);
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
}
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
}
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
}
TextureTools: make distance field processing into a stateful class.
8 years ago
struct DistanceField::State {
explicit State(UnsignedInt radius): shader{radius}, radius{radius} {}
DistanceFieldShader shader;
UnsignedInt radius;
GL::Mesh mesh;
};
DistanceField::DistanceField(const UnsignedInt radius): _state{new State{radius}} {
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 19: adapted TextureTools.
8 years ago
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::ARB::framebuffer_object);
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#endif
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
TextureTools: make distance field processing into a stateful class.
8 years ago
_state->mesh.setPrimitive(GL::MeshPrimitive::Triangles)
.setCount(3);
GL: don't include MAGNUM_shader_vertex_id on ES2 builds. It makes one think such feature *could* be supported there, while it couldn't.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
DebugTools, MeshTools, TextureTools: handle broken gl_VertexID. DebugTools::textureSubImage(), MeshTools::fullScreenTriangle() and TextureTools::distanceField() all plagued by this on SwiftShader.
7 years ago
if(!GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
GL: don't include MAGNUM_shader_vertex_id on ES2 builds. It makes one think such feature *could* be supported there, while it couldn't.
7 years ago
#endif
TextureTools: make distance field processing into a stateful class.
8 years ago
{
TextureTools: properly use float literals for vertex data.
3 years ago
constexpr Vector2 triangle[]{
{-1.0f, 1.0f},
{-1.0f, -3.0f},
{ 3.0f, 1.0f}
TextureTools: make distance field processing into a stateful class.
8 years ago
};
GL::Buffer buffer;
buffer.setData(triangle, GL::BufferUsage::StaticDraw);
Use Utility::move() and swap() instead of STL almost everywhere. Partially needed to avoid build breakages because Corrade itself switched as well, partially because a cleanup is always good. Done except for (STL-heavy) code that's deprecated or SceneGraph-related APIs that are still quite full of STL as well.
3 years ago
_state->mesh.addVertexBuffer(Utility::move(buffer), 0, DistanceFieldShader::Position());
TextureTools: make distance field processing into a stateful class.
8 years ago
}
}
TextureTools: make the DistanceField class movable. No reason not to, even though the move is destructive. Also unblocks Text::DistanceFieldGlyphCache which wasn't movable due to this and one other problem.
3 years ago
DistanceField::DistanceField(DistanceField&&) noexcept = default;
TextureTools: make distance field processing into a stateful class.
8 years ago
DistanceField::~DistanceField() = default;
TextureTools: make the DistanceField class movable. No reason not to, even though the move is destructive. Also unblocks Text::DistanceFieldGlyphCache which wasn't movable due to this and one other problem.
3 years ago
DistanceField& DistanceField::operator=(DistanceField&&) noexcept = default;
TextureTools: make distance field processing into a stateful class.
8 years ago
UnsignedInt DistanceField::radius() const { return _state->radius; }
TextureTools: add a DistanceField overload taking a framebuffer. So one can directly read it back on GLES without having to wrap the texture in a framebuffer again. This change also puts the framebuffer completeness check *before* the clear() and bind() which makes it no longer emit a GL error. The error is still silent though, which isn't nice. Gotta fix that eventually as well.
3 years ago
void DistanceField::operator()(GL::Texture2D& input, GL::Framebuffer& output, const Range2Di& rectangle, const Vector2i&
TextureTools: make distance field processing into a stateful class.
8 years ago
#ifdef MAGNUM_TARGET_GLES
imageSize
#endif
) {
Added some TODOs.
13 years ago
/** @todo Disable depth test, blending and then enable it back (if was previously) */
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Reducing pointer chasings, part 3f: less pointer passing in TextureTools.
13 years ago
Vector2i imageSize = input.imageSize(0);
TextureTools: ported distanceField() to OpenGL 2.1 and OpenGL ES. * Older GLSL doesn't have texelFetch() and related things, working around it by using classical texture() and normalized floating-point coordinates. But that needs to have Texture::imageSize() passed, which is not available in OpenGL ES, thus the user must specify it explicitly there. On desktop OpenGL that parameter is ignored. * Older GLSL doesn't have gl_VertexID, thus vertex buffer must be created and vertex data passed expliticly. * GLSL ES 2.0 doesn't have one-component texture format and TextureFormat::Luminance probably isn't renderable anywhere, thus TextureFormat::RGB should be used, although it is inefficient. * Checking for framebuffer completeness, if not complete, nothing is done. * Re-eabled building of TextureTools library in all ES PKGBUILDs.
13 years ago
#endif
TextureTools: assert that DistanceField output is framebuffer-drawable. If it's not, it's a programmer error (i.e., don't use Luminance or packed formats, won't work), and since there's no way for the API to report a failure in a programmatic way, this was causing hard-to-track errors.
3 years ago
CORRADE_ASSERT(output.checkStatus(GL::FramebufferTarget::Draw) == GL::Framebuffer::Status::Complete,
"TextureTools::DistanceField: output texture format not framebuffer-drawable:" << output.checkStatus(GL::FramebufferTarget::Draw), );
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
TextureTools: fix DistanceField to not be slightly shifted. The original implementation wrongly assumed that the input and output pixel centers align, which would only be a case if the ratio of the input and output sizes would be odd. Which it in practice isn't, usually it's a 1024x1024 texture scaled down to 128x128 or something like that. The flipped test cases added in the previous commit now pass. According to the benchmark, the new code is very slightly slower (~815 µs vs ~805 before). The new code isn't really more complex than the old one, it just does slightly different work -- there are new corner case in the initial logic for marking the pixel inside or outside, on the other hand some corner cases that had to be handled in the previous case are no longer a thing.
3 years ago
/* The shader assumes that the ratio between the output and input is a
multiple of 2, causing output pixel *centers* to be aligned with input
pixel *edges* */
CORRADE_ASSERT(imageSize % rectangle.size() == Vector2i{0} &&
TextureTools: make DistanceField working with subrectangles. Just cannot use gl_FragCoord in here. That's it, that's the fix. What's however COMPLETELY unexpected is that this simple change made the process significantly faster on my Intel GPU, from ~815 µs to 670! I can't even pretend I understand what's going on here, but maybe doing less math in the fragment shader when calculating the texture coordinates (and thus possibly the driver having a better idea how to prefetch or schedule?) is what made this faster? Or maybe it's due to one uniform input less, and two interpolated values instead of four on the way from the vertex shader?
3 years ago
(imageSize/rectangle.size()) % 2 == Vector2i{0},
TextureTools: fix DistanceField to not be slightly shifted. The original implementation wrongly assumed that the input and output pixel centers align, which would only be a case if the ratio of the input and output sizes would be odd. Which it in practice isn't, usually it's a 1024x1024 texture scaled down to 128x128 or something like that. The flipped test cases added in the previous commit now pass. According to the benchmark, the new code is very slightly slower (~815 µs vs ~805 before). The new code isn't really more complex than the old one, it just does slightly different work -- there are new corner case in the initial logic for marking the pixel inside or outside, on the other hand some corner cases that had to be handled in the previous case are no longer a thing.
3 years ago
"TextureTools::DistanceField: expected input and output size ratio to be a multiple of 2, got" << Debug::packed << imageSize << "and" << Debug::packed << rectangle.size(), );
TextureTools: properly set framebuffer viewport in DistanceField.
3 years ago
/* Save existing viewport to restore it back after */
const Range2Di previousViewport = output.viewport();
TextureTools: add a DistanceField overload taking a framebuffer. So one can directly read it back on GLES without having to wrap the texture in a framebuffer again. This change also puts the framebuffer completeness check *before* the clear() and bind() which makes it no longer emit a GL error. The error is still silent though, which isn't nice. Gotta fix that eventually as well.
3 years ago
output
TextureTools: properly set framebuffer viewport in DistanceField.
3 years ago
.setViewport(rectangle)
TextureTools: add a DistanceField overload taking a framebuffer. So one can directly read it back on GLES without having to wrap the texture in a framebuffer again. This change also puts the framebuffer completeness check *before* the clear() and bind() which makes it no longer emit a GL error. The error is still silent though, which isn't nice. Gotta fix that eventually as well.
3 years ago
.bind();
TextureTools: fix DistanceField to not be slightly shifted. The original implementation wrongly assumed that the input and output pixel centers align, which would only be a case if the ratio of the input and output sizes would be odd. Which it in practice isn't, usually it's a 1024x1024 texture scaled down to 128x128 or something like that. The flipped test cases added in the previous commit now pass. According to the benchmark, the new code is very slightly slower (~815 µs vs ~805 before). The new code isn't really more complex than the old one, it just does slightly different work -- there are new corner case in the initial logic for marking the pixel inside or outside, on the other hand some corner cases that had to be handled in the previous case are no longer a thing.
3 years ago
_state->shader
TextureTools: make DistanceField working with subrectangles. Just cannot use gl_FragCoord in here. That's it, that's the fix. What's however COMPLETELY unexpected is that this simple change made the process significantly faster on my Intel GPU, from ~815 µs to 670! I can't even pretend I understand what's going on here, but maybe doing less math in the fragment shader when calculating the texture coordinates (and thus possibly the driver having a better idea how to prefetch or schedule?) is what made this faster? Or maybe it's due to one uniform input less, and two interpolated values instead of four on the way from the vertex shader?
3 years ago
.bindTexture(input)
.setImageSizeInverted(1.0f/Vector2(imageSize))
.draw(_state->mesh);
TextureTools: properly set framebuffer viewport in DistanceField.
3 years ago
/* Restore the previous viewport */
output.setViewport(previousViewport);
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
}
TextureTools: add a DistanceField overload taking a framebuffer. So one can directly read it back on GLES without having to wrap the texture in a framebuffer again. This change also puts the framebuffer completeness check *before* the clear() and bind() which makes it no longer emit a GL error. The error is still silent though, which isn't nice. Gotta fix that eventually as well.
3 years ago
void DistanceField::operator()(GL::Texture2D& input, GL::Texture2D& output, const Range2Di& rectangle, const Vector2i&
#ifdef MAGNUM_TARGET_GLES
imageSize
#endif
) {
GL::Framebuffer framebuffer{rectangle};
framebuffer.attachTexture(GL::Framebuffer::ColorAttachment(0), output, 0);
operator()(input, framebuffer, rectangle
#ifdef MAGNUM_TARGET_GLES
, imageSize
#endif
);
}
TextureTools: initial rude implementation of distance field computation. Not yet ported anywhere else than GL >= 3.3 with some GL 4.3 features. Still, this closes #3.
13 years ago
}}