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.
11336 Commits
21 Branches
19 Tags
70 MiB
Tree: f88c0f5327
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f88c0f5327'
${ noResults }
magnum/src/Magnum/Text/Renderer.cpp

722 lines
36 KiB
Raw Normal View History Unescape

Text: initial implementation of font and text rendering. The library uses FreeType for glyph pre-rendering and basic glyph geometry and HarfBuzz for text layouting (i.e. ligatures, kerning, ...). Currently all used glyphs must be prerendered into texture atlas, other glyphs are simply not rendered (although the layouting code handles them like if they are there). Text rendering supports UTF-8, although glyph pre-rendering is currently ASCII only, as I couldn't find any working implementation of Unicode STL function in recent GCC versions. Will be fixed later.
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,
Here we go again.
1 year ago
2020, 2021, 2022, 2023, 2024, 2025
It's October already?!
2 years ago
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.
Text: initial implementation of font and text rendering. The library uses FreeType for glyph pre-rendering and basic glyph geometry and HarfBuzz for text layouting (i.e. ligatures, kerning, ...). Currently all used glyphs must be prerendered into texture atlas, other glyphs are simply not rendered (although the layouting code handles them like if they are there). Text rendering supports UTF-8, although glyph pre-rendering is currently ASCII only, as I couldn't find any working implementation of Unicode STL function in recent GCC versions. Will be fixed later.
14 years ago
*/
Text: renamed Text::TextRenderer to Text::Renderer. No redundant naming. Text::Renderer2D and Text::Renderer3D is typedef'd to old name, the typedefs are deprecated and will be removed in some future release.
13 years ago
#include "Renderer.h"
Text: initial implementation of font and text rendering. The library uses FreeType for glyph pre-rendering and basic glyph geometry and HarfBuzz for text layouting (i.e. ligatures, kerning, ...). Currently all used glyphs must be prerendered into texture atlas, other glyphs are simply not rendered (although the layouting code handles them like if they are there). Text rendering supports UTF-8, although glyph pre-rendering is currently ASCII only, as I couldn't find any working implementation of Unicode STL function in recent GCC versions. Will be fixed later.
14 years ago
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
#include <Corrade/Containers/StridedArrayView.h>
Text: fix the non-GL build.
3 years ago
#include <Corrade/Containers/Optional.h>
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
#include <Corrade/Containers/Triple.h>
#include "Magnum/Math/Functions.h"
Text: fix the non-GL build.
3 years ago
#include "Magnum/Math/Range.h"
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
#include "Magnum/Text/AbstractFont.h"
#include "Magnum/Text/AbstractGlyphCache.h"
Text: fix the non-GL build.
3 years ago
#include "Magnum/Text/Alignment.h"
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
#include "Magnum/Text/Direction.h"
#ifdef MAGNUM_TARGET_GL
Don't use deprecated Buffer functionality.
9 years ago
#include <Corrade/Containers/Array.h>
Text: port AbstractFont away from STL, adapt to Utility::Unicode changes. All std::string arguments are now a StringView, what returned a std::pair is now a Pair. STL compatibility headers are included on deprecated builds to ease porting, as usual. The only *really* breaking changes are in the internals, where an ArrayView<const char32_t> is used instead of std::u32string, which is in line with the change done in Utility::Unicode::utf32(); and a Triple is returned instead of a std::tuple. Behaviorally nothing changed except that fillGlyphCache() now asserts if the input string contains invalid UTF-8 (which is also in line with the cahnge done in Utility::Unicode).
3 years ago
#include <Corrade/Containers/ArrayViewStl.h> /** @todo remove once Renderer is STL-free */
#include <Corrade/Containers/StringStl.h> /** @todo remove once Renderer is STL-free */
Don't use deprecated Buffer functionality.
9 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/)
12 years ago
#include "Magnum/Mesh.h"
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
#include "Magnum/GL/Context.h"
#include "Magnum/GL/Extensions.h"
#include "Magnum/GL/Mesh.h"
Shaders: remove the AbstractVector base. 167 additions, 341 deletions. I think that speaks for itself about benefits of this base class.
5 years ago
#include "Magnum/Shaders/GenericGL.h"
Text: port Renderer away from deprecated APIs. The Renderer now does what was before redundantly copypasted into basically each and every font plugin.
3 years ago
#include "Magnum/Text/AbstractShaper.h"
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
#endif
Text: initial implementation of font and text rendering. The library uses FreeType for glyph pre-rendering and basic glyph geometry and HarfBuzz for text layouting (i.e. ligatures, kerning, ...). Currently all used glyphs must be prerendered into texture atlas, other glyphs are simply not rendered (although the layouting code handles them like if they are there). Text rendering supports UTF-8, although glyph pre-rendering is currently ASCII only, as I couldn't find any working implementation of Unicode STL function in recent GCC versions. Will be fixed later.
14 years ago
namespace Magnum { namespace Text {
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
Range2D renderLineGlyphPositionsInto(const AbstractFont& font, const Float size, const LayoutDirection direction, const Containers::StridedArrayView1D<const Vector2>& glyphOffsets, const Containers::StridedArrayView1D<const Vector2>& glyphAdvances, Vector2& cursor, const Containers::StridedArrayView1D<Vector2>& glyphPositions) {
CORRADE_ASSERT(glyphAdvances.size() == glyphOffsets.size() &&
glyphPositions.size() == glyphOffsets.size(),
"Text::renderLineGlyphPositionsInto(): expected glyphOffsets, glyphAdvances and output views to have the same size, got" << glyphOffsets.size() << Debug::nospace << "," << glyphAdvances.size() << "and" << glyphPositions.size(), {});
CORRADE_ASSERT(direction == LayoutDirection::HorizontalTopToBottom,
"Text::renderLineGlyphPositionsInto(): only" << LayoutDirection::HorizontalTopToBottom << "is supported right now, got" << direction, {});
#ifdef CORRADE_NO_ASSERT
static_cast<void>(direction); /** @todo drop once implemented */
#endif
CORRADE_ASSERT(font.isOpened(),
"Text::renderLineGlyphPositionsInto(): no font opened", {});
const Float scale = size/font.size();
/* Combine the offsets and cursor advances and calculate the line rectangle
along the way. Initially the cursor is at origin and rectangle is empty,
with just the Y bounds from font metrics. */
Text: update some TODOs with newly gained knowledge.
2 years ago
/** @todo this needs an update for vertical text */
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
Range2D rectangle{cursor + Vector2::yAxis(font.descent()*scale),
cursor + Vector2::yAxis(font.ascent()*scale)};
for(UnsignedInt i = 0; i != glyphOffsets.size(); ++i) {
/* The glyphOffsets and output are allowed to be aliased, so make sure
the value isn't stomped on when writing the output */
glyphPositions[i] = cursor + glyphOffsets[i]*scale;
cursor += glyphAdvances[i]*scale;
/* Extend the line rectangle with the cursor range */
Text: update some TODOs with newly gained knowledge.
2 years ago
/** @todo this assumes left-to-right / top-to-bottom ordering of
shaped glyphs (which HarfBuzz does for both directions however),
add some checks to verify that assumption */
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
rectangle.max() = Math::max(rectangle.max(), cursor);
}
return rectangle;
}
Text: initial implementation of font and text rendering. The library uses FreeType for glyph pre-rendering and basic glyph geometry and HarfBuzz for text layouting (i.e. ligatures, kerning, ...). Currently all used glyphs must be prerendered into texture atlas, other glyphs are simply not rendered (although the layouting code handles them like if they are there). Text rendering supports UTF-8, although glyph pre-rendering is currently ASCII only, as I couldn't find any working implementation of Unicode STL function in recent GCC versions. Will be fixed later.
14 years ago
namespace {
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
Range2D renderGlyphQuadsInto(const AbstractGlyphCache& cache, const Float scale, const Containers::StridedArrayView1D<const Vector2>& glyphPositions, const Containers::StridedArrayView1D<const UnsignedInt>& glyphIds, const Containers::StridedArrayView1D<Vector2>& vertexPositions, const Containers::StridedArrayView1D<Vector2>& vertexTextureCoordinates, const Containers::StridedArrayView1D<Float>& vertexTextureLayers) {
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
CORRADE_ASSERT(glyphIds.size() == glyphPositions.size(),
"Text::renderGlyphQuadsInto(): expected glyphIds and glyphPositions views to have the same size, got" << glyphIds.size() << "and" << glyphPositions.size(), {});
CORRADE_ASSERT(vertexPositions.size() == glyphPositions.size()*4 &&
vertexTextureCoordinates.size() == glyphPositions.size()*4,
"Text::renderGlyphQuadsInto(): expected vertexPositions and vertexTextureCoordinates views to have" << glyphPositions.size()*4 << "elements, got" << vertexPositions.size() << "and" << vertexTextureCoordinates.size(), {});
/* Should be ensured by the callers below */
CORRADE_INTERNAL_ASSERT(!vertexTextureLayers || vertexTextureLayers.size() == vertexTextureCoordinates.size());
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
/* Direct views on the cache data */
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
const Vector2 inverseCacheSize = 1.0f/Vector2{cache.size().xy()};
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
const Containers::StridedArrayView1D<const Vector2i> cacheGlyphOffsets = cache.glyphOffsets();
const Containers::StridedArrayView1D<const Int> cacheGlyphLayers = cache.glyphLayers();
const Containers::StridedArrayView1D<const Range2Di> cacheGlyphRectangles = cache.glyphRectangles();
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
/* Create quads for each glyph and calculate the glyph bound rectangle
along the way. */
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
Range2D rectangle;
for(std::size_t i = 0; i != glyphIds.size(); ++i) {
/* 2---3
| |
| |
| |
0---1 */
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
const UnsignedInt glyphId = glyphIds[i];
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
const Range2D quad = Range2D::fromSize(
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
glyphPositions[i] + Vector2{cacheGlyphOffsets[glyphId]}*scale,
Vector2{cacheGlyphRectangles[glyphId].size()}*scale);
const Range2D texture = Range2D{cacheGlyphRectangles[glyphId]}
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
.scaled(inverseCacheSize);
const std::size_t i4 = i*4;
for(UnsignedByte j = 0; j != 4; ++j) {
/* ✨ */
vertexPositions[i4 + j] = Math::lerp(quad.min(), quad.max(), BitVector2{j});
vertexTextureCoordinates[i4 + j] = Math::lerp(texture.min(), texture.max(), BitVector2{j});
}
/* Fill also a texture layer if desirable. For 2D output the caller
already checked that the cache is 2D. */
if(vertexTextureLayers) for(std::size_t j = 0; j != 4; ++j)
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
vertexTextureLayers[i4 + j] = cacheGlyphLayers[glyphId];
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
/* Extend the rectangle with current glyph bounds */
rectangle = Math::join(rectangle, quad);
}
return rectangle;
}
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
Range2D renderGlyphQuadsInto(const AbstractFont& font, const Float size, const AbstractGlyphCache& cache, const Containers::StridedArrayView1D<const Vector2>& glyphPositions, const Containers::StridedArrayView1D<const UnsignedInt>& fontGlyphIds, const Containers::StridedArrayView1D<Vector2>& vertexPositions, const Containers::StridedArrayView1D<Vector2>& vertexTextureCoordinates, const Containers::StridedArrayView1D<Float>& vertexTextureLayers) {
CORRADE_ASSERT(font.isOpened(),
"Text::renderGlyphQuadsInto(): no font opened", {});
Text: taking a pointer in cache.findFont() is stupid, don't. Especially given that nullptr causes an assert. All call sites basically ended up passing a &font and all that extra annoyance just doesn't make sense. Given this API is still relatively recent, I'm not bothering with backwards compatibility.
3 years ago
const Containers::Optional<UnsignedInt> fontId = cache.findFont(font);
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
CORRADE_ASSERT(fontId,
"Text::renderGlyphQuadsInto(): font not found among" << cache.fontCount() << "fonts in passed glyph cache", {});
/* First map the font-local glyph IDs to cache-global, abusing the texture
coordinate output array as the storage. Not vertex positions, as those
are allowed to be aliased with glyphPositions by the caller and this
process would overwrite them.
This also means we need to duplicate the size assertions here, to avoid
asserting inside glyphIdsInto() instead and confusing the user. */
CORRADE_ASSERT(fontGlyphIds.size() == glyphPositions.size(),
"Text::renderGlyphQuadsInto(): expected fontGlyphIds and glyphPositions views to have the same size, got" << fontGlyphIds.size() << "and" << glyphPositions.size(), {});
CORRADE_ASSERT(vertexPositions.size() == glyphPositions.size()*4 &&
vertexTextureCoordinates.size() == glyphPositions.size()*4,
"Text::renderGlyphQuadsInto(): expected vertexPositions and vertexTextureCoordinates views to have" << glyphPositions.size()*4 << "elements, got" << vertexPositions.size() << "and" << vertexTextureCoordinates.size(), {});
const Containers::StridedArrayView1D<UnsignedInt> glyphIds = Containers::arrayCast<UnsignedInt>(vertexTextureCoordinates.every(4));
cache.glyphIdsInto(*fontId, fontGlyphIds, glyphIds);
/* Delegate to the above */
return renderGlyphQuadsInto(cache, size/font.size(), glyphPositions, glyphIds, vertexPositions, vertexTextureCoordinates, vertexTextureLayers);
}
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
}
Range2D renderGlyphQuadsInto(const AbstractFont& font, const Float size, const AbstractGlyphCache& cache, const Containers::StridedArrayView1D<const Vector2>& glyphPositions, const Containers::StridedArrayView1D<const UnsignedInt>& glyphIds, const Containers::StridedArrayView1D<Vector2>& vertexPositions, const Containers::StridedArrayView1D<Vector3>& vertexTextureCoordinates) {
return renderGlyphQuadsInto(font, size, cache, glyphPositions, glyphIds, vertexPositions, vertexTextureCoordinates.slice(&Vector3::xy), vertexTextureCoordinates.slice(&Vector3::z));
}
Range2D renderGlyphQuadsInto(const AbstractFont& font, const Float size, const AbstractGlyphCache& cache, const Containers::StridedArrayView1D<const Vector2>& glyphPositions, const Containers::StridedArrayView1D<const UnsignedInt>& glyphIds, const Containers::StridedArrayView1D<Vector2>& vertexPositions, const Containers::StridedArrayView1D<Vector2>& vertexTextureCoordinates) {
CORRADE_ASSERT(cache.size().z() == 1,
"Text::renderGlyphQuadsInto(): can't use this overload with an array glyph cache", {});
return renderGlyphQuadsInto(font, size, cache, glyphPositions, glyphIds, vertexPositions, vertexTextureCoordinates, nullptr);
}
Text: add renderGlyphQuadsInto() overload taking cache-global glyph IDs. Which also allows the internals to be a bit simpler / potentially more efficient, as the implementation can now access the glyph cache contents directly, without a getter.
3 years ago
Range2D renderGlyphQuadsInto(const AbstractGlyphCache& cache, const Float scale, const Containers::StridedArrayView1D<const Vector2>& glyphPositions, const Containers::StridedArrayView1D<const UnsignedInt>& glyphIds, const Containers::StridedArrayView1D<Vector2>& vertexPositions, const Containers::StridedArrayView1D<Vector3>& vertexTextureCoordinates) {
return renderGlyphQuadsInto(cache, scale, glyphPositions, glyphIds, vertexPositions, vertexTextureCoordinates.slice(&Vector3::xy), vertexTextureCoordinates.slice(&Vector3::z));
}
Range2D renderGlyphQuadsInto(const AbstractGlyphCache& cache, const Float scale, const Containers::StridedArrayView1D<const Vector2>& glyphPositions, const Containers::StridedArrayView1D<const UnsignedInt>& glyphIds, const Containers::StridedArrayView1D<Vector2>& vertexPositions, const Containers::StridedArrayView1D<Vector2>& vertexTextureCoordinates) {
CORRADE_ASSERT(cache.size().z() == 1,
"Text::renderGlyphQuadsInto(): can't use this overload with an array glyph cache", {});
return renderGlyphQuadsInto(cache, scale, glyphPositions, glyphIds, vertexPositions, vertexTextureCoordinates, nullptr);
}
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
Range2D alignRenderedLine(const Range2D& lineRectangle, const LayoutDirection direction, const Alignment alignment, const Containers::StridedArrayView1D<Vector2>& positions) {
CORRADE_ASSERT(direction == LayoutDirection::HorizontalTopToBottom,
"Text::alignRenderedLine(): only" << LayoutDirection::HorizontalTopToBottom << "is supported right now, got" << direction, {});
Text: introduce Alignment::*Start and *End. Based on the actual text direction (either explicitly set or detected), these resolve to either *Left or *Right. For the Text::Renderer it's done automatically inside (and there's no way to actually set the direction from outside due to the API being ancient and limited), for the align*() utils the alignment has to be explicitly resolved using a new alignmentForDirection() utility.
2 years ago
CORRADE_ASSERT(
Text: rename Alignment::*Start to *Begin. The naming was adopted from CSS direction-aware alignment and it took me quite a while to realize it feels alien, since everything else is using "begin" and "end", not "start" and "end". So I'm renaming for consistency. These enums were originally introduced about 8 months ago but I don't think anyone is using these yet, since they're not really advertised anywhere and the existing to-be-deprecated high-level text renderer API is so shitty that I don't expect it to be used for BIDI text and such, at all. Sorry if you do, heh.
1 year ago
(UnsignedByte(alignment) & Implementation::AlignmentHorizontal) != Implementation::AlignmentBegin &&
Text: introduce Alignment::*Start and *End. Based on the actual text direction (either explicitly set or detected), these resolve to either *Left or *Right. For the Text::Renderer it's done automatically inside (and there's no way to actually set the direction from outside due to the API being ancient and limited), for the align*() utils the alignment has to be explicitly resolved using a new alignmentForDirection() utility.
2 years ago
(UnsignedByte(alignment) & Implementation::AlignmentHorizontal) != Implementation::AlignmentEnd,
"Text::alignRenderedLine():" << alignment << "has to be resolved to *Left / *Right before being passed to this function", {});
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
#ifdef CORRADE_NO_ASSERT
static_cast<void>(direction); /** @todo drop once implemented */
#endif
/** @todo this again assumes horizontal direction, needs to be updated once
vertical (and possibly mixed horizontal/vertical) text is possible */
Text: tighten up align*() internals with unreachable assertions. There shouldn't be any other values passed to these. Compilers, don't even attempt to say that the alignment value is now maybe uninitialized, I'm watching you!
2 years ago
Float alignmentOffsetX;
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
if((UnsignedByte(alignment) & Implementation::AlignmentHorizontal) == Implementation::AlignmentLeft)
alignmentOffsetX = -lineRectangle.left();
else if((UnsignedByte(alignment) & Implementation::AlignmentHorizontal) == Implementation::AlignmentCenter) {
alignmentOffsetX = -lineRectangle.centerX();
/* Integer alignment */
if(UnsignedByte(alignment) & Implementation::AlignmentIntegral)
alignmentOffsetX = Math::round(alignmentOffsetX);
}
else if((UnsignedByte(alignment) & Implementation::AlignmentHorizontal) == Implementation::AlignmentRight)
alignmentOffsetX = -lineRectangle.right();
Text: tighten up align*() internals with unreachable assertions. There shouldn't be any other values passed to these. Compilers, don't even attempt to say that the alignment value is now maybe uninitialized, I'm watching you!
2 years ago
else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
/* Shift all positions */
for(Vector2& i: positions)
i.x() += alignmentOffsetX;
return lineRectangle.translated(Vector2::xAxis(alignmentOffsetX));
}
Range2D alignRenderedBlock(const Range2D& blockRectangle, const LayoutDirection direction, const Alignment alignment, const Containers::StridedArrayView1D<Vector2>& positions) {
CORRADE_ASSERT(direction == LayoutDirection::HorizontalTopToBottom,
"Text::alignRenderedBlock(): only" << LayoutDirection::HorizontalTopToBottom << "is supported right now, got" << direction, {});
Text: introduce Alignment::*Start and *End. Based on the actual text direction (either explicitly set or detected), these resolve to either *Left or *Right. For the Text::Renderer it's done automatically inside (and there's no way to actually set the direction from outside due to the API being ancient and limited), for the align*() utils the alignment has to be explicitly resolved using a new alignmentForDirection() utility.
2 years ago
CORRADE_ASSERT(
Text: rename Alignment::*Start to *Begin. The naming was adopted from CSS direction-aware alignment and it took me quite a while to realize it feels alien, since everything else is using "begin" and "end", not "start" and "end". So I'm renaming for consistency. These enums were originally introduced about 8 months ago but I don't think anyone is using these yet, since they're not really advertised anywhere and the existing to-be-deprecated high-level text renderer API is so shitty that I don't expect it to be used for BIDI text and such, at all. Sorry if you do, heh.
1 year ago
(UnsignedByte(alignment) & Implementation::AlignmentHorizontal) != Implementation::AlignmentBegin &&
Text: introduce Alignment::*Start and *End. Based on the actual text direction (either explicitly set or detected), these resolve to either *Left or *Right. For the Text::Renderer it's done automatically inside (and there's no way to actually set the direction from outside due to the API being ancient and limited), for the align*() utils the alignment has to be explicitly resolved using a new alignmentForDirection() utility.
2 years ago
(UnsignedByte(alignment) & Implementation::AlignmentHorizontal) != Implementation::AlignmentEnd,
"Text::alignRenderedBlock():" << alignment << "has to be resolved to *Left / *Right before being passed to this function", {});
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
#ifdef CORRADE_NO_ASSERT
static_cast<void>(direction); /** @todo drop once implemented */
#endif
/** @todo this assumes vertical layout advance, needs to be updated once
other directions are possible */
Text: tighten up align*() internals with unreachable assertions. There shouldn't be any other values passed to these. Compilers, don't even attempt to say that the alignment value is now maybe uninitialized, I'm watching you!
2 years ago
Float alignmentOffsetY;
if((UnsignedByte(alignment) & Implementation::AlignmentVertical) == Implementation::AlignmentLine)
alignmentOffsetY = 0.0f;
else if((UnsignedByte(alignment) & Implementation::AlignmentVertical) == Implementation::AlignmentBottom)
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
alignmentOffsetY = -blockRectangle.bottom();
else if((UnsignedByte(alignment) & Implementation::AlignmentVertical) == Implementation::AlignmentMiddle) {
alignmentOffsetY = -blockRectangle.centerY();
/* Integer alignment */
if(UnsignedByte(alignment) & Implementation::AlignmentIntegral)
alignmentOffsetY = Math::round(alignmentOffsetY);
}
else if((UnsignedByte(alignment) & Implementation::AlignmentVertical) == Implementation::AlignmentTop)
alignmentOffsetY = -blockRectangle.top();
Text: tighten up align*() internals with unreachable assertions. There shouldn't be any other values passed to these. Compilers, don't even attempt to say that the alignment value is now maybe uninitialized, I'm watching you!
2 years ago
else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
/* Shift all positions */
for(Vector2& i: positions)
i.y() += alignmentOffsetY;
return blockRectangle.translated(Vector2::yAxis(alignmentOffsetY));
}
namespace {
template<class T> void renderGlyphQuadIndicesIntoInternal(const UnsignedInt glyphOffset, const Containers::StridedArrayView1D<T>& indices) {
CORRADE_ASSERT(indices.size() % 6 == 0,
"Text::renderGlyphQuadIndicesInto(): expected the indices view size to be divisible by 6, got" << indices.size(), );
const UnsignedInt glyphCount = indices.size()/6;
#ifndef CORRADE_NO_ASSERT
const UnsignedLong maxValue = UnsignedLong(glyphOffset)*4 + UnsignedLong(glyphCount)*4;
#endif
CORRADE_ASSERT(maxValue <= (1ull << 8*sizeof(T)),
"Text::renderGlyphQuadIndicesInto(): max index value of" << maxValue - 1 << "cannot fit into a" << 8*sizeof(T) << Debug::nospace << "-bit type", );
Text: using new type aliases in whole Text namespace.
13 years ago
for(UnsignedInt i = 0; i != glyphCount; ++i) {
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
/* 2---3 2 3---5
| | |\ \ |
| | | \ \ |
| | | \ \|
0---1 0---1 4 */
const UnsignedInt i4 = (glyphOffset + i)*4;
const UnsignedInt i6 = i*6;
indices[i6 + 0] = i4 + 0;
indices[i6 + 1] = i4 + 1;
indices[i6 + 2] = i4 + 2;
indices[i6 + 3] = i4 + 2;
indices[i6 + 4] = i4 + 1;
indices[i6 + 5] = i4 + 3;
Text: reworked TextRenderer internals. * Common layouting code in separate non-templated class. * Direct creation of interleaved vertex array and compressed index buffer, saves some memory operations and removes MeshTools dependency. * Preparation for mutable TextRenderer implementation.
13 years ago
}
}
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
}
void renderGlyphQuadIndicesInto(UnsignedInt glyphOffset, const Containers::StridedArrayView1D<UnsignedInt>& indices) {
renderGlyphQuadIndicesIntoInternal(glyphOffset, indices);
}
void renderGlyphQuadIndicesInto(UnsignedInt glyphOffset, const Containers::StridedArrayView1D<UnsignedShort>& indices) {
renderGlyphQuadIndicesIntoInternal(glyphOffset, indices);
}
void renderGlyphQuadIndicesInto(UnsignedInt glyphOffset, const Containers::StridedArrayView1D<UnsignedByte>& indices) {
renderGlyphQuadIndicesIntoInternal(glyphOffset, indices);
}
Text: utility for mapping input text byte ranges to output glyphs. For text selection and cursor movement.
2 years ago
Containers::Pair<UnsignedInt, UnsignedInt> glyphRangeForBytes(const Containers::StridedArrayView1D<const UnsignedInt>& clusters, const UnsignedInt begin, const UnsignedInt end) {
if(clusters.isEmpty())
return {};
/* Make the begin always less than or equal to end */
const bool reverseBeginEnd = begin > end;
const UnsignedInt beginForward = reverseBeginEnd ? end : begin;
const UnsignedInt endForward = reverseBeginEnd ? begin : end;
/* Make the cluster array always in an ascending order as well */
const bool reverseClusters = clusters.front() > clusters.back();
const Containers::StridedArrayView1D<const UnsignedInt> clustersForward =
reverseClusters ? clusters.flipped<0>() : clusters;
/* The glyph begin is the last glyph that has the cluster ID not larger
than `begin`, or the end */
UnsignedInt glyphBegin = 0;
while(glyphBegin != clustersForward.size() && clustersForward[glyphBegin] < beginForward && (glyphBegin + 1 == clustersForward.size() || clustersForward[glyphBegin + 1] <= beginForward))
++glyphBegin;
/* If `begin` was pointing in the middle of a cluster, for example of a
ligature, or (wrongly) inside a multi-byte UTF-8 char, go back to find
the cluster begin */
if(glyphBegin != clustersForward.size()) while(glyphBegin && clustersForward[glyphBegin - 1] == clustersForward[glyphBegin])
--glyphBegin;
/* The end is then the first glyph after glyph begin that has the cluster
ID larger or equal to `end`. Unless `begin` was the same as `end`, then
the returned glyph end is same as returned glyph begin. */
UnsignedInt glyphEnd = glyphBegin;
if(beginForward != endForward) while(glyphEnd != clustersForward.size() && clustersForward[glyphEnd] < endForward)
++glyphEnd;
/* If the clusters were in reverse direction, reverse the actual glyph IDs
as well. And this way the begin is greater or equal to end, so they're
swapped too. */
const Containers::Pair<UnsignedInt, UnsignedInt> out = reverseClusters ?
Containers::pair(UnsignedInt(clustersForward.size()) - glyphEnd,
UnsignedInt(clustersForward.size()) - glyphBegin) :
Containers::pair(glyphBegin, glyphEnd);
/* Then, if the begin and end was swapped, swap the output again as well */
return reverseBeginEnd ?
Containers::pair(out.second(), out.first()) :
out;
}
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
#ifdef MAGNUM_TARGET_GL
namespace {
Text: no need to explicitly specify Z coordinate in 3D text. The coordinate is always 0 and Mesh can be configured to add it implicitly. The code is now nearly the same for 2D and 3D, will redo it without templates later.
13 years ago
struct Vertex {
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
Vector2 position, textureCoordinates;
Text: reworked TextRenderer internals. * Common layouting code in separate non-templated class. * Direct creation of interleaved vertex array and compressed index buffer, saves some memory operations and removes MeshTools dependency. * Preparation for mutable TextRenderer implementation.
13 years ago
};
Text: the Renderer can take just AbstractGlyphCache, not GlyphCache. It doesn't need to access anything else than what the base API provides, doesn't render with it, and doesn't expose the instance via any getter either. Even though the Renderer is scheduled for a total rework and changing the old API may feel like throwaway work, this change alone doesn't break anything and allows me to test certain new corner cases.
3 years ago
std::tuple<std::vector<Vertex>, Range2D> renderVerticesInternal(AbstractFont& font, const AbstractGlyphCache& cache, const Float size, const std::string& text, const Alignment alignment) {
Text: port Renderer away from deprecated APIs. The Renderer now does what was before redundantly copypasted into basically each and every font plugin.
3 years ago
/* This was originally added as a runtime error into plugin implementations
during the transition period for the new AbstractGlyphCache API, now
it's an assert in the transition period for the Renderer API. Shouldn't
get triggered by existing code that uses 2D caches. */
CORRADE_ASSERT(cache.size().z() == 1,
"Text::Renderer: array glyph caches are not supported", {});
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
/* Find this font in the cache and assert in the high-level API already to
avoid confusion */
Text: taking a pointer in cache.findFont() is stupid, don't. Especially given that nullptr causes an assert. All call sites basically ended up passing a &font and all that extra annoyance just doesn't make sense. Given this API is still relatively recent, I'm not bothering with backwards compatibility.
3 years ago
CORRADE_ASSERT(cache.findFont(font),
Text: port Renderer away from deprecated APIs. The Renderer now does what was before redundantly copypasted into basically each and every font plugin.
3 years ago
"Text::Renderer: font not found among" << cache.fontCount() << "fonts in passed glyph cache", {});
Text: support for multi-line text rendering.
13 years ago
/* Output data, reserve memory as when the text would be ASCII-only. In
reality the actual vertex count will be smaller, but allocating more at
once is better than reallocating many times later. */
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
std::vector<Vertex> vertices;
Text: support for multi-line text rendering.
13 years ago
vertices.reserve(text.size()*4);
Text: reworked TextRenderer internals. * Common layouting code in separate non-templated class. * Direct creation of interleaved vertex array and compressed index buffer, saves some memory operations and removes MeshTools dependency. * Preparation for mutable TextRenderer implementation.
13 years ago
Text: port Renderer away from deprecated APIs. The Renderer now does what was before redundantly copypasted into basically each and every font plugin.
3 years ago
/* Scaling factor, line advance, total rendered bounds, initial line
position, last+1 vertex on previous line */
const Float scale = size/font.size();
const Vector2 lineAdvance = Vector2::yAxis(font.lineHeight()*scale);
Using Range2D instead of Rectangle everywhere. Encourages vectorization and generic usage even more. Some functions were rewritten to make use of the new features, resulting in shorter and more readable code. This also fixes the annoying naming collision with WINAPI Rectangle() function. The old Rectangle is now subclass of Range2D, is marked as deprecated and will be removed in future release.
13 years ago
Range2D rectangle;
Text: support for multi-line text rendering.
13 years ago
Vector2 linePosition;
/* Temp buffer so we don't allocate for each new line */
std::string line;
line.reserve(text.size());
Text: port Renderer away from deprecated APIs. The Renderer now does what was before redundantly copypasted into basically each and every font plugin.
3 years ago
/* Create a shaper */
/** @todo even with reusing a shaper this is all horrific, rework!! */
Containers::Pointer<AbstractShaper> shaper = font.createShaper();
Text: support for multi-line text rendering.
13 years ago
Text: introduce Alignment::*Start and *End. Based on the actual text direction (either explicitly set or detected), these resolve to either *Left or *Right. For the Text::Renderer it's done automatically inside (and there's no way to actually set the direction from outside due to the API being ancient and limited), for the align*() utils the alignment has to be explicitly resolved using a new alignmentForDirection() utility.
2 years ago
/* Start/End alignment resolved based on what the shaper detects for the
first line. Not great, but can't do much better with this old limited
API. */
/** @todo rework all this, again */
Containers::Optional<Alignment> resolvedAlignment;
Text: support for multi-line text rendering.
13 years ago
/* Render each line separately and align it horizontally */
std::size_t pos, prevPos = 0;
do {
/* Empty line, nothing to do (the rest is done below in while expression) */
if((pos = text.find('\n', prevPos)) == prevPos) continue;
/* Copy the line into the temp buffer */
line.assign(text, prevPos, pos-prevPos);
Text: avoid a temporary allocation for storing glyph info in Renderer. The new API makes it possible to alias storage for the glyph offsets, advances and IDs (20 bytes per glyph) directly with the output positions + texcoords (16 bytes per glyph, times four) by splitting the retrieval in two steps. I wonder how long will it take before this bites back, heh.
3 years ago
/* Shape the line */
Text: port Renderer away from deprecated APIs. The Renderer now does what was before redundantly copypasted into basically each and every font plugin.
3 years ago
shaper->shape(line);
Text: support for multi-line text rendering.
13 years ago
/* Verify that we don't reallocate anything. The only problem might
arise when the layouter decides to compose one character from more
Text: port Renderer away from deprecated APIs. The Renderer now does what was before redundantly copypasted into basically each and every font plugin.
3 years ago
than one glyph (i.e. accents). Will remove the asserts when this
Text: support for multi-line text rendering.
13 years ago
issue arises. */
Text: port Renderer away from deprecated APIs. The Renderer now does what was before redundantly copypasted into basically each and every font plugin.
3 years ago
CORRADE_INTERNAL_ASSERT(vertices.size() + shaper->glyphCount()*4 <= vertices.capacity());
Text: avoid a temporary allocation for storing glyph info in Renderer. The new API makes it possible to alias storage for the glyph offsets, advances and IDs (20 bytes per glyph) directly with the output positions + texcoords (16 bytes per glyph, times four) by splitting the retrieval in two steps. I wonder how long will it take before this bites back, heh.
3 years ago
vertices.resize(vertices.size() + shaper->glyphCount()*4);
/* Retrieve glyph offsets and advances directly into the output array
to not have to allocate a temp buffer; the offsets then get
converted to absolute positions. The renderLineGlyphPositionsInto()
is aware of this and will make sure to read the input before writing
to it. Taking every fourth item as the positions are subsequently
in-place converted to quads by renderGlyphQuadsInto() below and
putting them just into a prefix would cause them to be overwritten
too early. */
const Containers::StridedArrayView1D<Vertex> lineVertices = Containers::stridedArrayView(vertices).exceptPrefix(vertices.size() - shaper->glyphCount()*4);
const Containers::StridedArrayView1D<Vector2> glyphOffsetsPositions = lineVertices.slice(&Vertex::position).every(4);
const Containers::StridedArrayView1D<Vector2> glyphAdvances = lineVertices.slice(&Vertex::textureCoordinates).every(4);
shaper->glyphOffsetsAdvancesInto(
glyphOffsetsPositions,
glyphAdvances);
Text: support for multi-line text rendering.
13 years ago
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
Vector2 cursor = linePosition;
Text: avoid a temporary allocation for storing glyph info in Renderer. The new API makes it possible to alias storage for the glyph offsets, advances and IDs (20 bytes per glyph) directly with the output positions + texcoords (16 bytes per glyph, times four) by splitting the retrieval in two steps. I wonder how long will it take before this bites back, heh.
3 years ago
/* Render line glyph positions, aliasing the offsets */
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
const Range2D lineRectangle = renderLineGlyphPositionsInto(
font,
size,
/** @todo direction hardcoded here */
LayoutDirection::HorizontalTopToBottom,
Text: avoid a temporary allocation for storing glyph info in Renderer. The new API makes it possible to alias storage for the glyph offsets, advances and IDs (20 bytes per glyph) directly with the output positions + texcoords (16 bytes per glyph, times four) by splitting the retrieval in two steps. I wonder how long will it take before this bites back, heh.
3 years ago
glyphOffsetsPositions,
glyphAdvances,
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
cursor,
Text: avoid a temporary allocation for storing glyph info in Renderer. The new API makes it possible to alias storage for the glyph offsets, advances and IDs (20 bytes per glyph) directly with the output positions + texcoords (16 bytes per glyph, times four) by splitting the retrieval in two steps. I wonder how long will it take before this bites back, heh.
3 years ago
glyphOffsetsPositions);
/* Retrieve the glyph IDs directly into the output array, again to not
have to allocate a temp buffer. The place where IDs get stored is
where glyph advances were stored before and which were combined into
glyph positions, and ultimately this location is where texture
coordinates get written. Again the renderGlyphQuadsInto() is aware
of this and will make sure to read the IDs before writing the quads.
Again taking every fourth item as these are subsequently converted
to quads by the function and putting them just into a prefix would
cause them to be overwritten too early. */
const Containers::StridedArrayView1D<UnsignedInt> glyphIds = Containers::arrayCast<UnsignedInt>(glyphAdvances);
shaper->glyphIdsInto(glyphIds);
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
/* Create quads from the positions */
const Range2D lineQuadRectangle = renderGlyphQuadsInto(
font,
size,
cache,
Text: avoid a temporary allocation for storing glyph info in Renderer. The new API makes it possible to alias storage for the glyph offsets, advances and IDs (20 bytes per glyph) directly with the output positions + texcoords (16 bytes per glyph, times four) by splitting the retrieval in two steps. I wonder how long will it take before this bites back, heh.
3 years ago
glyphOffsetsPositions,
glyphIds,
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
lineVertices.slice(&Vertex::position),
lineVertices.slice(&Vertex::textureCoordinates));
Text: introduce Alignment::*Start and *End. Based on the actual text direction (either explicitly set or detected), these resolve to either *Left or *Right. For the Text::Renderer it's done automatically inside (and there's no way to actually set the direction from outside due to the API being ancient and limited), for the align*() utils the alignment has to be explicitly resolved using a new alignmentForDirection() utility.
2 years ago
/* Resolve the alignment based on what the shaper detected (if
anything). Assume there are no font plugins that would produce
vertical shape direction by default. */
/** @todo drop all this once the shaper instance is configurable from
outside */
if(!resolvedAlignment) {
const ShapeDirection shapeDirection = shaper->direction();
CORRADE_INTERNAL_ASSERT(
shapeDirection != ShapeDirection::TopToBottom &&
shapeDirection != ShapeDirection::BottomToTop);
resolvedAlignment = alignmentForDirection(alignment,
/** @todo direction hardcoded here */
LayoutDirection::HorizontalTopToBottom,
shapeDirection);
}
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
/* Horizontally align the line, using either of the rectangles based on
which alignment is desired */
const Range2D alignedLineRectangle = alignRenderedLine(
Text: introduce Alignment::*Start and *End. Based on the actual text direction (either explicitly set or detected), these resolve to either *Left or *Right. For the Text::Renderer it's done automatically inside (and there's no way to actually set the direction from outside due to the API being ancient and limited), for the align*() utils the alignment has to be explicitly resolved using a new alignmentForDirection() utility.
2 years ago
UnsignedByte(*resolvedAlignment) & Implementation::AlignmentGlyphBounds ?
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
lineQuadRectangle : lineRectangle,
/** @todo direction hardcoded here */
LayoutDirection::HorizontalTopToBottom,
Text: introduce Alignment::*Start and *End. Based on the actual text direction (either explicitly set or detected), these resolve to either *Left or *Right. For the Text::Renderer it's done automatically inside (and there's no way to actually set the direction from outside due to the API being ancient and limited), for the align*() utils the alignment has to be explicitly resolved using a new alignmentForDirection() utility.
2 years ago
*resolvedAlignment,
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
lineVertices.slice(&Vertex::position));
/* Extend the rectangle with final line bounds */
rectangle = Math::join(rectangle, alignedLineRectangle);
Text: support for multi-line text rendering.
13 years ago
/* Move to next line */
} while(prevPos = pos+1,
Text: fix rendering of scaled multi-line text. Take text size into account when advancing lines. I would probably not run into this issue if I would visually test this on anything else than unscaled pixel art font.
13 years ago
linePosition -= lineAdvance,
Text: support for multi-line text rendering.
13 years ago
pos != std::string::npos);
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
const Range2D alignedRectangle = alignRenderedBlock(
rectangle,
/** @todo direction hardcoded here */
LayoutDirection::HorizontalTopToBottom,
Text: introduce Alignment::*Start and *End. Based on the actual text direction (either explicitly set or detected), these resolve to either *Left or *Right. For the Text::Renderer it's done automatically inside (and there's no way to actually set the direction from outside due to the API being ancient and limited), for the align*() utils the alignment has to be explicitly resolved using a new alignmentForDirection() utility.
2 years ago
*resolvedAlignment,
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
Containers::stridedArrayView(vertices).slice(&Vertex::position));
Text: added tests for TextRenderer. Exposed vertex and index buffer of mutable TextRenderer, fixed computation of bounding rectangle.
13 years ago
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
return std::make_tuple(Utility::move(vertices), alignedRectangle);
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
}
Text: support for aligning rendered text.
13 years ago
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
std::pair<Containers::Array<char>, MeshIndexType> renderIndicesInternal(const UnsignedInt glyphCount) {
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
const UnsignedInt vertexCount = glyphCount*4;
const UnsignedInt indexCount = glyphCount*6;
Text: reworked TextRenderer internals. * Common layouting code in separate non-templated class. * Direct creation of interleaved vertex array and compressed index buffer, saves some memory operations and removes MeshTools dependency. * Preparation for mutable TextRenderer implementation.
13 years ago
Get rid of annoying unsigned byte arrays. `char*` is now the default type for byte arrays. Results in shorter code, less annoyances and more convenient testing. As is the case with Corrade, I'm not doing any compatibility/deprecation layer, as most of these functions is not widely used anyway.
11 years ago
Containers::Array<char> indices;
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
MeshIndexType indexType;
Text: it's totally fine to have 256 vertices indexed with UnsignedByte.
13 years ago
if(vertexCount <= 256) {
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
indexType = MeshIndexType::UnsignedByte;
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
indices = Containers::Array<char>{NoInit, indexCount*sizeof(UnsignedByte)};
renderGlyphQuadIndicesInto(0, Containers::arrayCast<UnsignedByte>(indices));
Text: it's totally fine to have 256 vertices indexed with UnsignedByte.
13 years ago
} else if(vertexCount <= 65536) {
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
indexType = MeshIndexType::UnsignedShort;
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
indices = Containers::Array<char>{NoInit, indexCount*sizeof(UnsignedShort)};
renderGlyphQuadIndicesInto(0, Containers::arrayCast<UnsignedShort>(indices));
Text: reworked TextRenderer internals. * Common layouting code in separate non-templated class. * Direct creation of interleaved vertex array and compressed index buffer, saves some memory operations and removes MeshTools dependency. * Preparation for mutable TextRenderer implementation.
13 years ago
} else {
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
indexType = MeshIndexType::UnsignedInt;
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
indices = Containers::Array<char>{NoInit, indexCount*sizeof(UnsignedInt)};
renderGlyphQuadIndicesInto(0, Containers::arrayCast<UnsignedInt>(indices));
Text: reworked TextRenderer internals. * Common layouting code in separate non-templated class. * Direct creation of interleaved vertex array and compressed index buffer, saves some memory operations and removes MeshTools dependency. * Preparation for mutable TextRenderer implementation.
13 years ago
}
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
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
return {Utility::move(indices), indexType};
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
}
Text: the Renderer can take just AbstractGlyphCache, not GlyphCache. It doesn't need to access anything else than what the base API provides, doesn't render with it, and doesn't expose the instance via any getter either. Even though the Renderer is scheduled for a total rework and changing the old API may feel like throwaway work, this change alone doesn't break anything and allows me to test certain new corner cases.
3 years ago
std::tuple<GL::Mesh, Range2D> renderInternal(AbstractFont& font, const AbstractGlyphCache& cache, Float size, const std::string& text, GL::Buffer& vertexBuffer, GL::Buffer& indexBuffer, GL::BufferUsage usage, Alignment alignment) {
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
/* Render vertices and upload them */
std::vector<Vertex> vertices;
Using Range2D instead of Rectangle everywhere. Encourages vectorization and generic usage even more. Some functions were rewritten to make use of the new features, resulting in shorter and more readable code. This also fixes the annoying naming collision with WINAPI Rectangle() function. The old Rectangle is now subclass of Range2D, is marked as deprecated and will be removed in future release.
13 years ago
Range2D rectangle;
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
std::tie(vertices, rectangle) = renderVerticesInternal(font, cache, size, text, alignment);
vertexBuffer.setData(vertices, usage);
const UnsignedInt glyphCount = vertices.size()/4;
const UnsignedInt indexCount = glyphCount*6;
/* Render indices and upload them */
Get rid of annoying unsigned byte arrays. `char*` is now the default type for byte arrays. Results in shorter code, less annoyances and more convenient testing. As is the case with Corrade, I'm not doing any compatibility/deprecation layer, as most of these functions is not widely used anyway.
11 years ago
Containers::Array<char> indices;
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
MeshIndexType indexType;
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
std::tie(indices, indexType) = renderIndicesInternal(glyphCount);
indexBuffer.setData(indices, usage);
Text: initial implementation of font and text rendering. The library uses FreeType for glyph pre-rendering and basic glyph geometry and HarfBuzz for text layouting (i.e. ligatures, kerning, ...). Currently all used glyphs must be prerendered into texture atlas, other glyphs are simply not rendered (although the layouting code handles them like if they are there). Text rendering supports UTF-8, although glyph pre-rendering is currently ASCII only, as I couldn't find any working implementation of Unicode STL function in recent GCC versions. Will be fixed later.
14 years ago
Text: non-templated base for TextRenderer. Saves a lot of duplicated generated code.
13 years ago
/* Configure mesh except for vertex buffer (depends on dimension count, done
in subclass) */
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
GL::Mesh mesh;
Extracted Primitive enum from Mesh to MeshPrimitive. Because we can't forward-declare class members we would need to include whole Mesh (along with all OpenGL headers and other stuff) just to use Primitive enum. The old Mesh::Primitive is now alias to new one, is marked as deprecated and will be removed in future release.
13 years ago
mesh.setPrimitive(MeshPrimitive::Triangles)
Don't differentiate between vertex and index count in Mesh. Only one value from these two was used in the end, wasting precious bytes. Also these two values were used to differentiate between indexed and non-indexed mesh (instead of relying on actual index buffer being bound), which was very confusing. This approach looks more clean. The MeshView class is not yet updated, as the change would expose some features that aren't possible in current implementation (base vertex specification). Merged Mesh::setVertexCount() and Mesh::setIndexCount() into one Mesh::setCount(), the two original functions are now guarded aliases to the new one, are marked as deprecated and will be removed in future release, similarly for the getters. In particular, if the mesh is indexed, setVertexCount() does nothing and vertexCount() returns 0. The setIndexCount() and indexCount() do and return the same regardless of whether the mesh is indexed or not.
12 years ago
.setCount(indexCount)
Text: minor cleanup.
13 years ago
.setIndexBuffer(indexBuffer, 0, indexType, 0, vertices.size());
Text: initial implementation of font and text rendering. The library uses FreeType for glyph pre-rendering and basic glyph geometry and HarfBuzz for text layouting (i.e. ligatures, kerning, ...). Currently all used glyphs must be prerendered into texture atlas, other glyphs are simply not rendered (although the layouting code handles them like if they are there). Text rendering supports UTF-8, although glyph pre-rendering is currently ASCII only, as I couldn't find any working implementation of Unicode STL function in recent GCC versions. Will be fixed later.
14 years ago
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
return std::make_tuple(Utility::move(mesh), rectangle);
Text: initial implementation of font and text rendering. The library uses FreeType for glyph pre-rendering and basic glyph geometry and HarfBuzz for text layouting (i.e. ligatures, kerning, ...). Currently all used glyphs must be prerendered into texture atlas, other glyphs are simply not rendered (although the layouting code handles them like if they are there). Text rendering supports UTF-8, although glyph pre-rendering is currently ASCII only, as I couldn't find any working implementation of Unicode STL function in recent GCC versions. Will be fixed later.
14 years ago
}
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
}
Text: the Renderer can take just AbstractGlyphCache, not GlyphCache. It doesn't need to access anything else than what the base API provides, doesn't render with it, and doesn't expose the instance via any getter either. Even though the Renderer is scheduled for a total rework and changing the old API may feel like throwaway work, this change alone doesn't break anything and allows me to test certain new corner cases.
3 years ago
std::tuple<std::vector<Vector2>, std::vector<Vector2>, std::vector<UnsignedInt>, Range2D> AbstractRenderer::render(AbstractFont& font, const AbstractGlyphCache& cache, Float size, const std::string& text, Alignment alignment) {
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
/* Render vertices */
std::vector<Vertex> vertices;
Using Range2D instead of Rectangle everywhere. Encourages vectorization and generic usage even more. Some functions were rewritten to make use of the new features, resulting in shorter and more readable code. This also fixes the annoying naming collision with WINAPI Rectangle() function. The old Rectangle is now subclass of Range2D, is marked as deprecated and will be removed in future release.
13 years ago
Range2D rectangle;
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
std::tie(vertices, rectangle) = renderVerticesInternal(font, cache, size, text, alignment);
/* Deinterleave the vertices */
std::vector<Vector2> positions, textureCoordinates;
positions.reserve(vertices.size());
positions.reserve(textureCoordinates.size());
for(const auto& v: vertices) {
positions.push_back(v.position);
textureCoordinates.push_back(v.textureCoordinates);
}
/* Render indices */
const UnsignedInt glyphCount = vertices.size()/4;
std::vector<UnsignedInt> indices(glyphCount*6);
Text: new, reusable and composable guts for the Renderer. The awful original STL-heavy public API is kept the same for now, it's just the internals being now implemented using brand new APIs that are actually usable with multiple fonts, font sizes and runs with different scripts/languages/directions. There's also preparation for configurable vertical text layouting, although for now the functionality asserts that horizontal text is used. This also makes Renderer.h header available on non-GL builds, as the new APIs don't rely on a class full of GL objects anymore. The class will get eventually renamed and moved to a dedicated RendererGL.h header, but for now this partial update has to suffice.
3 years ago
renderGlyphQuadIndicesInto(0, indices);
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
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
return std::make_tuple(Utility::move(positions), Utility::move(textureCoordinates), Utility::move(indices), rectangle);
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
}
Text: the Renderer can take just AbstractGlyphCache, not GlyphCache. It doesn't need to access anything else than what the base API provides, doesn't render with it, and doesn't expose the instance via any getter either. Even though the Renderer is scheduled for a total rework and changing the old API may feel like throwaway work, this change alone doesn't break anything and allows me to test certain new corner cases.
3 years ago
template<UnsignedInt dimensions> std::tuple<GL::Mesh, Range2D> Renderer<dimensions>::render(AbstractFont& font, const AbstractGlyphCache& cache, Float size, const std::string& text, GL::Buffer& vertexBuffer, GL::Buffer& indexBuffer, GL::BufferUsage usage, Alignment alignment) {
Text: non-templated base for TextRenderer. Saves a lot of duplicated generated code.
13 years ago
/* Finalize mesh configuration and return the result */
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
auto r = renderInternal(font, cache, size, text, vertexBuffer, indexBuffer, usage, alignment);
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
GL::Mesh& mesh = std::get<0>(r);
Renamed Mesh::addInterleavedVertexBuffer() to addVertexBuffer(). Obvious change after previous commit, there is no other function alternative to distinguish it from.
13 years ago
mesh.addVertexBuffer(vertexBuffer, 0,
Shaders: remove the AbstractVector base. 167 additions, 341 deletions. I think that speaks for itself about benefits of this base class.
5 years ago
typename Shaders::GenericGL<dimensions>::Position(
Shaders::GenericGL<dimensions>::Position::Components::Two),
typename Shaders::GenericGL<dimensions>::TextureCoordinates());
Don't use `return std::move()` where it is not needed.
11 years ago
return r;
Text: non-templated base for TextRenderer. Saves a lot of duplicated generated code.
13 years ago
}
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#if defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN)
Text: renamed Text::TextRenderer to Text::Renderer. No redundant naming. Text::Renderer2D and Text::Renderer3D is typedef'd to old name, the typedefs are deprecated and will be removed in some future release.
13 years ago
AbstractRenderer::BufferMapImplementation AbstractRenderer::bufferMapImplementation = &AbstractRenderer::bufferMapImplementationFull;
AbstractRenderer::BufferUnmapImplementation AbstractRenderer::bufferUnmapImplementation = &AbstractRenderer::bufferUnmapImplementationDefault;
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
void* AbstractRenderer::bufferMapImplementationFull(GL::Buffer& buffer, GLsizeiptr) {
return buffer.map(GL::Buffer::MapAccess::WriteOnly);
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
}
Expose CHROMIUM_map_sub only for NaCl. It's not even in official registry.
11 years ago
#endif
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#if !defined(MAGNUM_TARGET_GLES2) || defined(CORRADE_TARGET_EMSCRIPTEN)
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
inline void* AbstractRenderer::bufferMapImplementation(GL::Buffer& buffer, GLsizeiptr length)
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
#else
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
void* AbstractRenderer::bufferMapImplementationRange(GL::Buffer& buffer, GLsizeiptr length)
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
#endif
{
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#ifndef CORRADE_TARGET_EMSCRIPTEN
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
return buffer.map(0, length, GL::Buffer::MapFlag::InvalidateBuffer|GL::Buffer::MapFlag::Write);
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#else
static_cast<void>(length);
return &buffer == &_indexBuffer ? _indexBufferData : _vertexBufferData;
#endif
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
}
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#if !defined(MAGNUM_TARGET_GLES2) || defined(CORRADE_TARGET_EMSCRIPTEN)
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
inline void AbstractRenderer::bufferUnmapImplementation(GL::Buffer& buffer)
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
#else
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
void AbstractRenderer::bufferUnmapImplementationDefault(GL::Buffer& buffer)
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
#endif
{
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#ifndef CORRADE_TARGET_EMSCRIPTEN
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
buffer.unmap();
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#else
buffer.setSubData(0, &buffer == &_indexBuffer ? _indexBufferData : _vertexBufferData);
#endif
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
}
Text: the Renderer can take just AbstractGlyphCache, not GlyphCache. It doesn't need to access anything else than what the base API provides, doesn't render with it, and doesn't expose the instance via any getter either. Even though the Renderer is scheduled for a total rework and changing the old API may feel like throwaway work, this change alone doesn't break anything and allows me to test certain new corner cases.
3 years ago
AbstractRenderer::AbstractRenderer(AbstractFont& font, const AbstractGlyphCache& cache, const Float size, const Alignment alignment): _vertexBuffer{GL::Buffer::TargetHint::Array}, _indexBuffer{GL::Buffer::TargetHint::ElementArray}, font(font), cache(cache), _fontSize{size}, _alignment(alignment), _capacity(0) {
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::ARB::map_buffer_range);
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#elif defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN)
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
if(GL::Context::current().isExtensionSupported<GL::Extensions::EXT::map_buffer_range>()) {
Text: renamed Text::TextRenderer to Text::Renderer. No redundant naming. Text::Renderer2D and Text::Renderer3D is typedef'd to old name, the typedefs are deprecated and will be removed in some future release.
13 years ago
bufferMapImplementation = &AbstractRenderer::bufferMapImplementationRange;
Dropped NaCl support.
9 years ago
} else {
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
MAGNUM_ASSERT_GL_EXTENSION_SUPPORTED(GL::Extensions::OES::mapbuffer);
Warning() << "Text::Renderer:" << GL::Extensions::EXT::map_buffer_range::string()
<< "is not supported, using inefficient" << GL::Extensions::OES::mapbuffer::string()
Text: fallback to OES_mapbuffer if EXT_map_buffer_range is not supported. The renderer emits warning about crappy hardware, similarly to what GlyphCache does.
13 years ago
<< "instead";
}
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
#endif
Text: non-templated base for TextRenderer. Saves a lot of duplicated generated code.
13 years ago
/* Vertex buffer configuration depends on dimension count, done in subclass */
Extracted Primitive enum from Mesh to MeshPrimitive. Because we can't forward-declare class members we would need to include whole Mesh (along with all OpenGL headers and other stuff) just to use Primitive enum. The old Mesh::Primitive is now alias to new one, is marked as deprecated and will be removed in future release.
13 years ago
_mesh.setPrimitive(MeshPrimitive::Triangles);
Text: non-templated base for TextRenderer. Saves a lot of duplicated generated code.
13 years ago
}
Modernize #1
9 years ago
AbstractRenderer::~AbstractRenderer() = default;
Text: non-templated base for TextRenderer. Saves a lot of duplicated generated code.
13 years ago
Text: the Renderer can take just AbstractGlyphCache, not GlyphCache. It doesn't need to access anything else than what the base API provides, doesn't render with it, and doesn't expose the instance via any getter either. Even though the Renderer is scheduled for a total rework and changing the old API may feel like throwaway work, this change alone doesn't break anything and allows me to test certain new corner cases.
3 years ago
template<UnsignedInt dimensions> Renderer<dimensions>::Renderer(AbstractFont& font, const AbstractGlyphCache& cache, const Float size, const Alignment alignment): AbstractRenderer(font, cache, size, alignment) {
Text: non-templated base for TextRenderer. Saves a lot of duplicated generated code.
13 years ago
/* Finalize mesh configuration */
Renamed Mesh::addInterleavedVertexBuffer() to addVertexBuffer(). Obvious change after previous commit, there is no other function alternative to distinguish it from.
13 years ago
_mesh.addVertexBuffer(_vertexBuffer, 0,
Shaders: remove the AbstractVector base. 167 additions, 341 deletions. I think that speaks for itself about benefits of this base class.
5 years ago
typename Shaders::GenericGL<dimensions>::Position(
Shaders::GenericGL<dimensions>::Position::Components::Two),
typename Shaders::GenericGL<dimensions>::TextureCoordinates());
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
}
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
void AbstractRenderer::reserve(const uint32_t glyphCount, const GL::BufferUsage vertexBufferUsage, const GL::BufferUsage indexBufferUsage) {
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
_capacity = glyphCount;
Text: using new type aliases in whole Text namespace.
13 years ago
const UnsignedInt vertexCount = glyphCount*4;
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
/* Allocate vertex buffer, reset vertex count */
Fix build without MAGNUM_BUILD_DEPRECATED. Updated Buffer test to check all data setting functions.
13 years ago
_vertexBuffer.setData({nullptr, vertexCount*sizeof(Vertex)}, vertexBufferUsage);
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#ifdef CORRADE_TARGET_EMSCRIPTEN
_vertexBufferData = Containers::Array<UnsignedByte>(vertexCount*sizeof(Vertex));
#endif
Don't differentiate between vertex and index count in Mesh. Only one value from these two was used in the end, wasting precious bytes. Also these two values were used to differentiate between indexed and non-indexed mesh (instead of relying on actual index buffer being bound), which was very confusing. This approach looks more clean. The MeshView class is not yet updated, as the change would expose some features that aren't possible in current implementation (base vertex specification). Merged Mesh::setVertexCount() and Mesh::setIndexCount() into one Mesh::setCount(), the two original functions are now guarded aliases to the new one, are marked as deprecated and will be removed in future release, similarly for the getters. In particular, if the mesh is indexed, setVertexCount() does nothing and vertexCount() returns 0. The setIndexCount() and indexCount() do and return the same regardless of whether the mesh is indexed or not.
12 years ago
_mesh.setCount(0);
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
/* Render indices */
Get rid of annoying unsigned byte arrays. `char*` is now the default type for byte arrays. Results in shorter code, less annoyances and more convenient testing. As is the case with Corrade, I'm not doing any compatibility/deprecation layer, as most of these functions is not widely used anyway.
11 years ago
Containers::Array<char> indexData;
Split the OpenGL layer out, pt 22: adapted Text.
8 years ago
MeshIndexType indexType;
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
std::tie(indexData, indexType) = renderIndicesInternal(glyphCount);
/* Allocate index buffer, reset index count and reconfigure buffer binding */
_indexBuffer.setData({nullptr, indexData.size()}, indexBufferUsage);
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#ifdef CORRADE_TARGET_EMSCRIPTEN
Text: fix Renderer compilation in Emscripten.
13 years ago
_indexBufferData = Containers::Array<UnsignedByte>(indexData.size());
Text: ported TextRenderer to not require buffer mapping in Emscripten. The mapping is faked with client-side array, which is then uploaded on "unmapping".
13 years ago
#endif
Don't differentiate between vertex and index count in Mesh. Only one value from these two was used in the end, wasting precious bytes. Also these two values were used to differentiate between indexed and non-indexed mesh (instead of relying on actual index buffer being bound), which was very confusing. This approach looks more clean. The MeshView class is not yet updated, as the change would expose some features that aren't possible in current implementation (base vertex specification). Merged Mesh::setVertexCount() and Mesh::setIndexCount() into one Mesh::setCount(), the two original functions are now guarded aliases to the new one, are marked as deprecated and will be removed in future release, similarly for the getters. In particular, if the mesh is indexed, setVertexCount() does nothing and vertexCount() returns 0. The setIndexCount() and indexCount() do and return the same regardless of whether the mesh is indexed or not.
12 years ago
_mesh.setCount(0)
Reducing pointer chasings, part 3g: less pointer passing in Text. The testing is now slightly more sloppy due to inability to not pass any Font or GlyphCache object. But it is actually better from user point of view, as it is now impossible to do that by accident.
13 years ago
.setIndexBuffer(_indexBuffer, 0, indexType, 0, vertexCount);
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
/* Prefill index buffer */
Get rid of annoying unsigned byte arrays. `char*` is now the default type for byte arrays. Results in shorter code, less annoyances and more convenient testing. As is the case with Corrade, I'm not doing any compatibility/deprecation layer, as most of these functions is not widely used anyway.
11 years ago
char* const indices = static_cast<char*>(bufferMapImplementation(_indexBuffer, indexData.size()));
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
CORRADE_INTERNAL_ASSERT(indices);
Text: added TODO.
13 years ago
/** @todo Emscripten: it can be done without this copying altogether */
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
std::copy(indexData.begin(), indexData.end(), indices);
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
bufferUnmapImplementation(_indexBuffer);
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
}
Text: renamed Text::TextRenderer to Text::Renderer. No redundant naming. Text::Renderer2D and Text::Renderer3D is typedef'd to old name, the typedefs are deprecated and will be removed in some future release.
13 years ago
void AbstractRenderer::render(const std::string& text) {
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
/* Render vertex data */
std::vector<Vertex> vertexData;
_rectangle = {};
Text: expose a Renderer::fontSize() getter.
4 years ago
std::tie(vertexData, _rectangle) = renderVerticesInternal(font, cache, _fontSize, text, _alignment);
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
const UnsignedInt glyphCount = vertexData.size()/4;
const UnsignedInt vertexCount = glyphCount*4;
const UnsignedInt indexCount = glyphCount*6;
Text: added tests for TextRenderer. Exposed vertex and index buffer of mutable TextRenderer, fixed computation of bounding rectangle.
13 years ago
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
CORRADE_ASSERT(glyphCount <= _capacity,
"Text::Renderer::render(): capacity" << _capacity << "too small to render" << glyphCount << "glyphs", );
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
/* Interleave the data into mapped buffer*/
Adapted to Corrade changes.
11 years ago
Containers::ArrayView<Vertex> vertices(static_cast<Vertex*>(bufferMapImplementation(_vertexBuffer,
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
vertexCount*sizeof(Vertex))), vertexCount);
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(vertices);
Text: de-duplicated rendering code in Renderer. All three rendering functions (separated, interleaved with upload to GPU, interleaved with mapping to GPU) are now using common code and then they reorder the data to fit particular requirements. The data shuffling might slow down things a bit, but it is optimized for the most common path (we are rendering to interleaved array, which then get unpacked if needed, not the other way around), so it shouldn't be an issue. No premature optimization again, please.
13 years ago
std::copy(vertexData.begin(), vertexData.end(), vertices.begin());
Text: use CHROMIUM_map_sub rather than OES_mapbuffer. OES_mapbuffer isn't available in (my) NaCl anyway and CHROMIUM_map_sub should be faster.
13 years ago
bufferUnmapImplementation(_vertexBuffer);
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
/* Update index count */
Don't differentiate between vertex and index count in Mesh. Only one value from these two was used in the end, wasting precious bytes. Also these two values were used to differentiate between indexed and non-indexed mesh (instead of relying on actual index buffer being bound), which was very confusing. This approach looks more clean. The MeshView class is not yet updated, as the change would expose some features that aren't possible in current implementation (base vertex specification). Merged Mesh::setVertexCount() and Mesh::setIndexCount() into one Mesh::setCount(), the two original functions are now guarded aliases to the new one, are marked as deprecated and will be removed in future release, similarly for the getters. In particular, if the mesh is indexed, setVertexCount() does nothing and vertexCount() returns 0. The setIndexCount() and indexCount() do and return the same regardless of whether the mesh is indexed or not.
12 years ago
_mesh.setCount(indexCount);
Text: mutable TextRenderer implementation. Allows fast text updates (using buffer mapping). Also fully documented the workflow.
13 years ago
}
Text: renamed Text::TextRenderer to Text::Renderer. No redundant naming. Text::Renderer2D and Text::Renderer3D is typedef'd to old name, the typedefs are deprecated and will be removed in some future release.
13 years ago
template class MAGNUM_TEXT_EXPORT Renderer<2>;
template class MAGNUM_TEXT_EXPORT Renderer<3>;
Make Doxygen spit less warnings. Oh where are the times when Doxygen didn't spit ANY warning.
13 years ago
#endif
Text: initial implementation of font and text rendering. The library uses FreeType for glyph pre-rendering and basic glyph geometry and HarfBuzz for text layouting (i.e. ligatures, kerning, ...). Currently all used glyphs must be prerendered into texture atlas, other glyphs are simply not rendered (although the layouting code handles them like if they are there). Text rendering supports UTF-8, although glyph pre-rendering is currently ASCII only, as I couldn't find any working implementation of Unicode STL function in recent GCC versions. Will be fixed later.
14 years ago
}}