mirror of https://github.com/mosra/magnum.git
Browse Source
This is a replacement for the existing AbstractRenderer and Renderer2D / Renderer3D classes, with no STL or other shittiness like excessive allocations, and with a much better feature set. Deprecation of the old APIs is going to happen next. Compared to the old implementation it doesn't make use of the complicated buffer mapping because -- unlike in 2012 -- such behavior was since deemed questionable as the driver (or whichever translation layer like ANGLE or Zink or Apple's GL-over-Metal) may still make a copy anyway and doing so prevents buffer orphaning. So it's right now just plain setData() / setSubData() calls. *If* it becomes some sort of a bottleneck (which I doubt), I may reconsider, or add something else like double buffering.pull/674/head
Vladimír Vondruš
1 year ago
12 changed files with 1437 additions and 8 deletions
@ -0,0 +1,306 @@
|
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
||||
2020, 2021, 2022, 2023, 2024, 2025 |
||||
Vladimír Vondruš <mosra@centrum.cz> |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a |
||||
copy of this software and associated documentation files (the "Software"), |
||||
to deal in the Software without restriction, including without limitation |
||||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||
and/or sell copies of the Software, and to permit persons to whom the |
||||
Software is furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included |
||||
in all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
DEALINGS IN THE SOFTWARE. |
||||
*/ |
||||
|
||||
#include "RendererGL.h" |
||||
|
||||
#include <Corrade/Containers/EnumSet.hpp> |
||||
#include <Corrade/Containers/StringView.h> |
||||
|
||||
#include "Magnum/Shaders/GenericGL.h" /* no link-time dependency here */ |
||||
#include "Magnum/Text/AbstractGlyphCache.h" |
||||
#include "Magnum/Text/Implementation/rendererState.h" |
||||
|
||||
/* Somehow on GCC 4.8 to 7 the {} passed as a default argument for
|
||||
ArrayView<const FeatureRange> causes "error: elements of array 'const class |
||||
Magnum::Text::FeatureRange [0]' have incomplete type". GCC 9 is fine, no |
||||
idea about version 8, but including the definition for it as well to be |
||||
safe. Similar problem happens with MSVC STL, where the initializer_list is |
||||
implemented as a (begin, end) pair and size() is a difference of those two |
||||
pointers. Which needs to know the type size to calculate the actual element |
||||
count. */ |
||||
#if (defined(CORRADE_TARGET_GCC) && __GNUC__ <= 8) || defined(CORRADE_TARGET_DINKUMWARE) |
||||
#include "Magnum/Text/Feature.h" |
||||
#endif |
||||
|
||||
namespace Magnum { namespace Text { |
||||
|
||||
Debug& operator<<(Debug& debug, const RendererGLFlag value) { |
||||
debug << "Text::RendererGLFlag" << Debug::nospace; |
||||
|
||||
switch(value) { |
||||
/* LCOV_EXCL_START */ |
||||
#define _c(v) case RendererGLFlag::v: return debug << "::" #v; |
||||
_c(GlyphPositionsClusters) |
||||
#undef _c |
||||
/* LCOV_EXCL_STOP */ |
||||
} |
||||
|
||||
return debug << "(" << Debug::nospace << Debug::hex << UnsignedByte(value) << Debug::nospace << ")"; |
||||
} |
||||
|
||||
Debug& operator<<(Debug& debug, const RendererGLFlags value) { |
||||
return Containers::enumSetDebugOutput(debug, value, "Text::RendererGLFlags{}", { |
||||
RendererGLFlag::GlyphPositionsClusters |
||||
}); |
||||
} |
||||
|
||||
struct RendererGL::State: Renderer::State { |
||||
explicit State(const AbstractGlyphCache& glyphCache, RendererGLFlags flags); |
||||
|
||||
GL::Buffer indices{GL::Buffer::TargetHint::ElementArray}, |
||||
vertices{GL::Buffer::TargetHint::Array}; |
||||
GL::Mesh mesh; |
||||
|
||||
/* Because querying GL buffer size is not possible on all platforms and it
|
||||
may be slow, track the size here. It's used to know whether the buffer |
||||
should be reuploaded as a whole or can be partially updated, updated in |
||||
both reserve() and render(). */ |
||||
UnsignedInt bufferGlyphCapacity = 0; |
||||
}; |
||||
|
||||
RendererGL::State::State(const AbstractGlyphCache& glyphCache, RendererGLFlags flags): Renderer::State{glyphCache, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, RendererFlags{UnsignedByte(flags)}} { |
||||
#ifdef MAGNUM_TARGET_GLES2 |
||||
CORRADE_ASSERT(glyphCache.size().z() == 1, |
||||
"Text::RendererGL: array glyph caches are not supported in OpenGL ES 2.0 and WebGL 1 builds", ); |
||||
#endif |
||||
|
||||
/* As documented in RendererGL::setIndexType(), use of 8-bit indices is
|
||||
discouraged on contemporary GPUs */ |
||||
indexType = minIndexType = MeshIndexType::UnsignedShort; |
||||
|
||||
/* Set up the mesh with the initial index type and zero primitives to draw.
|
||||
The count gets updated on each renderer(), index buffer properties each |
||||
time the index type changes. */ |
||||
mesh.setIndexBuffer(indices, 0, indexType) |
||||
.setCount(0); |
||||
#ifndef MAGNUM_TARGET_GLES2 |
||||
if(glyphCache.size().z() != 1) { |
||||
mesh.addVertexBuffer(vertices, 0, |
||||
Shaders::GenericGL2D::Position{}, |
||||
Shaders::GenericGL2D::TextureArrayCoordinates{}); |
||||
} else |
||||
#endif |
||||
{ |
||||
mesh.addVertexBuffer(vertices, 0, |
||||
Shaders::GenericGL2D::Position{}, |
||||
Shaders::GenericGL2D::TextureCoordinates{}); |
||||
} |
||||
} |
||||
|
||||
RendererGL::RendererGL(const AbstractGlyphCache& glyphCache, RendererGLFlags flags): Renderer{Containers::pointer<State>(glyphCache, flags)} {} |
||||
|
||||
RendererGL::RendererGL(RendererGL&&) noexcept = default; |
||||
|
||||
RendererGL::~RendererGL() = default; |
||||
|
||||
RendererGL& RendererGL::operator=(RendererGL&&) noexcept = default; |
||||
|
||||
RendererGLFlags RendererGL::flags() const { |
||||
return RendererGLFlags{UnsignedByte(_state->flags)}; |
||||
} |
||||
|
||||
GL::Mesh& RendererGL::mesh() { |
||||
return static_cast<State&>(*_state).mesh; |
||||
} |
||||
|
||||
const GL::Mesh& RendererGL::mesh() const { |
||||
return static_cast<const State&>(*_state).mesh; |
||||
} |
||||
|
||||
RendererGL& RendererGL::setIndexType(MeshIndexType atLeast) { |
||||
State& state = static_cast<State&>(*_state); |
||||
|
||||
Renderer::setIndexType(atLeast); |
||||
|
||||
/* Upload indices anew if the type is different from before. In this case
|
||||
it's also most likely that the size is bigger than before, so do it as |
||||
a setData() call instead of having a specialized setSubData() code path |
||||
if the total size shrinks. |
||||
|
||||
Besides the type, the capacity should not change compared to when the |
||||
buffer was last updated in reserve() or render(). (Which only holds for |
||||
builtin allocators, but RendererGL so far allows only builtin allocators |
||||
so that's fine. It however does *not* hold for `state.indexData`, as |
||||
that can stay larger if the index type becomes smaller, so verifying |
||||
against `state.glyphPositions` instead.) */ |
||||
CORRADE_INTERNAL_ASSERT(state.bufferGlyphCapacity == state.glyphPositions.size()); |
||||
if(GL::meshIndexType(state.indexType) != state.mesh.indexType()) { |
||||
state.indices.setData(state.indexData); |
||||
state.mesh.setIndexBuffer(state.indices, 0, state.indexType); |
||||
} |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
RendererGL& RendererGL::clear() { |
||||
Renderer::clear(); |
||||
static_cast<State&>(*_state).mesh.setCount(0); |
||||
return *this; |
||||
} |
||||
|
||||
RendererGL& RendererGL::reset() { |
||||
Renderer::reset(); |
||||
static_cast<State&>(*_state).mesh.setCount(0); |
||||
return *this; |
||||
} |
||||
|
||||
RendererGL& RendererGL::reserve(const UnsignedInt glyphCapacity, const UnsignedInt runCapacity) { |
||||
State& state = static_cast<State&>(*_state); |
||||
|
||||
Renderer::reserve(glyphCapacity, runCapacity); |
||||
|
||||
/* Upload indices anew if the capacity is bigger than before */ |
||||
if(state.bufferGlyphCapacity < glyphCapacity) { |
||||
state.indices.setData(state.indexData); |
||||
/* Update the mesh index buffer reference if the type changed */ |
||||
if(GL::meshIndexType(state.indexType) != state.mesh.indexType()) |
||||
state.mesh.setIndexBuffer(state.indices, 0, state.indexType); |
||||
|
||||
/* If the capacity isn't bigger, the index type shouldn't have changed
|
||||
either and so no upload needs to be done. It can change only if the new |
||||
capacity is too larger to fit the type used, or in a setIndexType() |
||||
call, but there we handle the reupload directly. */ |
||||
} else CORRADE_INTERNAL_ASSERT(GL::meshIndexType(state.indexType) == state.mesh.indexType()); |
||||
|
||||
/* Resize the vertex buffer and reupload its contents if the capacity is
|
||||
bigger than before */ |
||||
if(state.bufferGlyphCapacity < glyphCapacity) { |
||||
const UnsignedInt glyphSize = 4*( |
||||
#ifndef MAGNUM_TARGET_GLES2 |
||||
state.glyphCache.size().z() != 1 ? |
||||
sizeof(Implementation::VertexArray) : |
||||
#endif |
||||
sizeof(Implementation::Vertex)); |
||||
|
||||
/* The assumption in this case is that the capacity is bigger than the
|
||||
actually rendered glyph count, otherwise we'd have it all resized |
||||
and uploaded in render() already. Thus we have to do a bigger |
||||
setData() allocation first and then upload just a portion with |
||||
setSubData(). */ |
||||
CORRADE_INTERNAL_ASSERT(glyphCapacity > state.glyphCount); |
||||
state.vertices |
||||
.setData({nullptr, glyphCapacity*glyphSize}) |
||||
.setSubData(0, state.vertexData.prefix(state.glyphCount*glyphSize)); |
||||
} |
||||
|
||||
/* Remember the currently used capacity if it grew. It can happen that
|
||||
reserve() is called with a smaller capacity, or with just runCapacity |
||||
being larger, so this shouldn't reset that and cause needless reupload |
||||
next time. */ |
||||
state.bufferGlyphCapacity = Math::max(state.bufferGlyphCapacity, glyphCapacity); |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
Containers::Pair<Range2D, Range1Dui> RendererGL::render() { |
||||
State& state = static_cast<State&>(*_state); |
||||
|
||||
const Containers::Pair<Range2D, Range1Dui> out = Renderer::render(); |
||||
|
||||
/* Upload indices anew if the glyph count is bigger than before */ |
||||
if(state.bufferGlyphCapacity < state.glyphCount) { |
||||
state.indices.setData(state.indexData); |
||||
/* Update the mesh index buffer reference if the type changed */ |
||||
if(GL::meshIndexType(state.indexType) != state.mesh.indexType()) |
||||
state.mesh.setIndexBuffer(state.indices, 0, state.indexType); |
||||
|
||||
/* If the glyph count isn't bigger, the index type shouldn't have changed
|
||||
either. Same reasoning as in reserve() above. */ |
||||
} else CORRADE_INTERNAL_ASSERT(GL::meshIndexType(state.indexType) == state.mesh.indexType()); |
||||
|
||||
/* Upload vertices fully anew if the glyph count is bigger than before */ |
||||
const UnsignedInt glyphSize = 4*( |
||||
#ifndef MAGNUM_TARGET_GLES2 |
||||
state.glyphCache.size().z() != 1 ? |
||||
sizeof(Implementation::VertexArray) : |
||||
#endif |
||||
sizeof(Implementation::Vertex)); |
||||
if(state.bufferGlyphCapacity < state.glyphCount) { |
||||
/* Unlike in render(), it's just setData() alone, with the assumption
|
||||
that the render() caused the capacity to grow to fit exactly all |
||||
glyphs, and so we upload everything. (Which only holds for builtin |
||||
vertex allocators, but RendererGL so far allows only builtin |
||||
allocators so that's fine.) */ |
||||
CORRADE_INTERNAL_ASSERT( |
||||
state.vertexPositions.size() == state.glyphCount*4 && |
||||
state.vertexTextureCoordinates.size() == state.glyphCount*4); |
||||
state.vertices.setData(state.vertexData.prefix(state.glyphCount*glyphSize)); |
||||
|
||||
/* Otherwise upload just what was rendered new */ |
||||
} else { |
||||
const Range1Dui glyphRange = glyphsForRuns(out.second()); |
||||
state.vertices.setSubData(glyphRange.min()*glyphSize, state.vertexData.slice(glyphRange.min()*glyphSize, glyphRange.max()*glyphSize)); |
||||
} |
||||
|
||||
/* Remember the currently used capacity if it grew */ |
||||
state.bufferGlyphCapacity = Math::max(state.bufferGlyphCapacity, state.glyphCount); |
||||
|
||||
/* Set the mesh index count to exactly what was rendered in total */ |
||||
state.mesh.setCount(state.glyphCount*6); |
||||
|
||||
return out; |
||||
} |
||||
|
||||
RendererGL& RendererGL::add(AbstractShaper& shaper, const Float size, const Containers::StringView text, const UnsignedInt begin, const UnsignedInt end, const Containers::ArrayView<const FeatureRange> features) { |
||||
return static_cast<RendererGL&>(Renderer::add(shaper, size, text, begin, end, features)); |
||||
} |
||||
|
||||
RendererGL& RendererGL::add(AbstractShaper& shaper, const Float size, const Containers::StringView text, const UnsignedInt begin, const UnsignedInt end) { |
||||
return static_cast<RendererGL&>(Renderer::add(shaper, size, text, begin, end)); |
||||
} |
||||
|
||||
RendererGL& RendererGL::add(AbstractShaper& shaper, const Float size, const Containers::StringView text, const UnsignedInt begin, const UnsignedInt end, const std::initializer_list<FeatureRange> features) { |
||||
return static_cast<RendererGL&>(Renderer::add(shaper, size, text, begin, end, features)); |
||||
} |
||||
|
||||
RendererGL& RendererGL::add(AbstractShaper& shaper, const Float size, const Containers::StringView text, const Containers::ArrayView<const FeatureRange> features) { |
||||
return static_cast<RendererGL&>(Renderer::add(shaper, size, text, features)); |
||||
} |
||||
|
||||
RendererGL& RendererGL::add(AbstractShaper& shaper, const Float size, const Containers::StringView text) { |
||||
return static_cast<RendererGL&>(Renderer::add(shaper, size, text)); |
||||
} |
||||
|
||||
RendererGL& RendererGL::add(AbstractShaper& shaper, const Float size, const Containers::StringView text, const std::initializer_list<FeatureRange> features) { |
||||
return static_cast<RendererGL&>(Renderer::add(shaper, size, text, features)); |
||||
} |
||||
|
||||
Containers::Pair<Range2D, Range1Dui> RendererGL::render(AbstractShaper& shaper, const Float size, const Containers::StringView text, const Containers::ArrayView<const FeatureRange> features) { |
||||
/* Compared to Renderer::render() this calls our render() instead of
|
||||
Renderer::render() */ |
||||
add(shaper, size, text, features); |
||||
return render(); |
||||
} |
||||
|
||||
Containers::Pair<Range2D, Range1Dui> RendererGL::render(AbstractShaper& shaper, const Float size, const Containers::StringView text) { |
||||
return render(shaper, size, text, {}); |
||||
} |
||||
|
||||
Containers::Pair<Range2D, Range1Dui> RendererGL::render(AbstractShaper& shaper, const Float size, const Containers::StringView text, const std::initializer_list<FeatureRange> features) { |
||||
return render(shaper, size, text, Containers::arrayView(features)); |
||||
} |
||||
|
||||
}} |
||||
@ -0,0 +1,245 @@
|
||||
#ifndef Magnum_Text_RendererGL_h |
||||
#define Magnum_Text_RendererGL_h |
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
||||
2020, 2021, 2022, 2023, 2024, 2025 |
||||
Vladimír Vondruš <mosra@centrum.cz> |
||||
|
||||
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. |
||||
*/ |
||||
|
||||
/** @file
|
||||
* @brief Class @ref Magnum::Text::RendererGL, enum @ref Magnum::Text::RendererGLFlag, enum set @ref Magnum::Text::RendererGLFlags |
||||
* @m_since_latest |
||||
*/ |
||||
|
||||
#include "Magnum/configure.h" |
||||
|
||||
#ifdef MAGNUM_TARGET_GL |
||||
#include "Magnum/Text/Renderer.h" |
||||
|
||||
namespace Magnum { namespace Text { |
||||
|
||||
/**
|
||||
@brief OpenGL text renderer flag |
||||
@m_since_latest |
||||
|
||||
A superset of @ref RendererFlag. |
||||
|
||||
@note This enum is available only if Magnum is compiled with |
||||
@ref MAGNUM_TARGET_GL enabled (done by default). See @ref building-features |
||||
for more information. |
||||
|
||||
@see @ref RendererGLFlags, @ref RendererGL |
||||
*/ |
||||
/* Currently is the same as RendererFlag, but is made to a dedicated type to
|
||||
not cause a breaking change once GL-specific flags are introduced, such as |
||||
buffer mapping */ |
||||
enum class RendererGLFlag: UnsignedByte { |
||||
/** @copydoc RendererFlag::GlyphPositionsClusters */ |
||||
GlyphPositionsClusters = UnsignedByte(RendererFlag::GlyphPositionsClusters) |
||||
}; |
||||
|
||||
/**
|
||||
@debugoperatorenum{RendererGLFlag} |
||||
@m_since_latest |
||||
|
||||
@note This function is available only if Magnum is compiled with |
||||
@ref MAGNUM_TARGET_GL enabled (done by default). See @ref building-features |
||||
for more information. |
||||
*/ |
||||
MAGNUM_TEXT_EXPORT Debug& operator<<(Debug& output, RendererGLFlag value); |
||||
|
||||
/**
|
||||
@brief OpenGL text renderer flags |
||||
@m_since_latest |
||||
|
||||
@note This enum set is available only if Magnum is compiled with |
||||
@ref MAGNUM_TARGET_GL enabled (done by default). See @ref building-features |
||||
for more information. |
||||
|
||||
@see @ref RendererGL |
||||
*/ |
||||
typedef Containers::EnumSet<RendererGLFlag> RendererGLFlags; |
||||
|
||||
CORRADE_ENUMSET_OPERATORS(RendererGLFlags) |
||||
|
||||
/**
|
||||
@debugoperatorenum{RendererGLFlags} |
||||
@m_since_latest |
||||
|
||||
@note This function is available only if Magnum is compiled with |
||||
@ref MAGNUM_TARGET_GL enabled (done by default). See @ref building-features |
||||
for more information. |
||||
*/ |
||||
MAGNUM_TEXT_EXPORT Debug& operator<<(Debug& output, RendererGLFlags value); |
||||
|
||||
/**
|
||||
@brief OpenGL text renderer |
||||
@m_since_latest |
||||
|
||||
@note This class is available only if Magnum is compiled with |
||||
@ref MAGNUM_TARGET_GL enabled (done by default). See @ref building-features |
||||
for more information. |
||||
*/ |
||||
class MAGNUM_TEXT_EXPORT RendererGL: public Renderer { |
||||
public: |
||||
/**
|
||||
* @brief Construct |
||||
* @param glyphCache Glyph cache to use |
||||
* @param flags Opt-in feature flags |
||||
* |
||||
* Unlike with the @ref Renderer base, the OpenGL implementation needs |
||||
* to have a complete control over memory layout and allocation and |
||||
* thus it isn't possible to supply custom allocators. If you want the |
||||
* control, use @ref Renderer with custom index and vertex allocators |
||||
* and fill a @ref GL::Mesh instance with the data manually. |
||||
*/ |
||||
explicit RendererGL(const AbstractGlyphCache& glyphCache, RendererGLFlags flags = {}); |
||||
|
||||
/**
|
||||
* @brief Construct without creating the internal state and the OpenGL objects |
||||
* |
||||
* The constructed instance is equivalent to moved-from state, i.e. no |
||||
* APIs can be safely called on the object. Useful in cases where you |
||||
* will overwrite the instance later anyway. Move another object over |
||||
* it to make it useful. |
||||
* |
||||
* This function can be safely used for constructing (and later |
||||
* destructing) objects even without any OpenGL context being active. |
||||
* However note that this is a low-level and a potentially dangerous |
||||
* API, see the documentation of @ref NoCreate for alternatives. |
||||
*/ |
||||
explicit RendererGL(NoCreateT) noexcept: Renderer{NoCreate} {} |
||||
|
||||
/** @brief Copying is not allowed */ |
||||
RendererGL(RendererGL&) = delete; |
||||
|
||||
/**
|
||||
* @brief Move constructor |
||||
* |
||||
* Performs a destructive move, i.e. the original object isn't usable |
||||
* afterwards anymore. |
||||
*/ |
||||
RendererGL(RendererGL&&) noexcept; |
||||
|
||||
~RendererGL(); |
||||
|
||||
/** @brief Copying is not allowed */ |
||||
RendererGL& operator=(RendererGL&) = delete; |
||||
|
||||
/** @brief Move assignment */ |
||||
RendererGL& operator=(RendererGL&&) noexcept; |
||||
|
||||
/** @brief Flags */ |
||||
RendererGLFlags flags() const; |
||||
|
||||
/** @brief Mesh containing the rendered index and vertex data */ |
||||
GL::Mesh& mesh(); |
||||
const GL::Mesh& mesh() const; /**< @overload */ |
||||
|
||||
/**
|
||||
* @brief Set index type |
||||
* @return Reference to self (for method chaining) |
||||
* |
||||
* Calls @ref Renderer::setIndexType() and updates @ref mesh() with the |
||||
* rendered index data, if different from before. Compared to |
||||
* @ref Renderer, the default index type is |
||||
* @ref MeshIndexType::UnsignedShort, not |
||||
* @ref MeshIndexType::UnsignedByte, as use of 8-bit indices is |
||||
* discouraged on contemporary GPUs. |
||||
*/ |
||||
RendererGL& setIndexType(MeshIndexType atLeast); |
||||
|
||||
/**
|
||||
* @brief Reserve capacity for given glyph count |
||||
* @return Reference to self (for method chaining) |
||||
* |
||||
* Calls @ref Renderer::reserve() and updates @ref mesh() with the |
||||
* rendered index data, if different from before. |
||||
*/ |
||||
RendererGL& reserve(UnsignedInt glyphCapacity, UnsignedInt runCapacity); |
||||
|
||||
/**
|
||||
* @brief Clear rendered glyphs, runs and vertices |
||||
* @return Reference to self (for method chaining) |
||||
* |
||||
* Calls @ref Renderer::clear() and additionally also sets @ref mesh() |
||||
* index count to @cpp 0 @ce. |
||||
*/ |
||||
RendererGL& clear(); |
||||
|
||||
/**
|
||||
* @brief Reset internal renderer state |
||||
* @return Reference to self (for method chaining) |
||||
* |
||||
* Calls @ref Renderer::reset(), and additionally also sets @ref mesh() |
||||
* index count to @cpp 0 @ce. |
||||
*/ |
||||
RendererGL& reset(); |
||||
|
||||
/**
|
||||
* @brief Wrap up rendering of all text added so far |
||||
* |
||||
* Calls @ref Renderer::render(), updates @ref mesh() with the newly |
||||
* rendered vertex data and potentially updates also the index data, if |
||||
* different from before. |
||||
*/ |
||||
Containers::Pair<Range2D, Range1Dui> render(); |
||||
|
||||
/* Overloads to remove a WTF factor from method chaining order, and to
|
||||
ensure our render() is called instead of Render::render() */ |
||||
#ifndef DOXYGEN_GENERATING_OUTPUT |
||||
RendererGL& setCursor(const Vector2& cursor) { |
||||
return static_cast<RendererGL&>(Renderer::setCursor(cursor)); |
||||
} |
||||
RendererGL& setAlignment(Alignment alignment) { |
||||
return static_cast<RendererGL&>(Renderer::setAlignment(alignment)); |
||||
} |
||||
RendererGL& setLineAdvance(Float advance) { |
||||
return static_cast<RendererGL&>(Renderer::setLineAdvance(advance)); |
||||
} |
||||
RendererGL& setLayoutDirection(LayoutDirection direction) { |
||||
return static_cast<RendererGL&>(Renderer::setLayoutDirection(direction)); |
||||
} |
||||
|
||||
RendererGL& add(AbstractShaper& shaper, Float size, Containers::StringView text, UnsignedInt begin, UnsignedInt end, Containers::ArrayView<const FeatureRange> features); |
||||
RendererGL& add(AbstractShaper& shaper, Float size, Containers::StringView text, UnsignedInt begin, UnsignedInt end); |
||||
RendererGL& add(AbstractShaper& shaper, Float size, Containers::StringView text, UnsignedInt begin, UnsignedInt end, std::initializer_list<FeatureRange> features); |
||||
RendererGL& add(AbstractShaper& shaper, Float size, Containers::StringView text, Containers::ArrayView<const FeatureRange> features); |
||||
RendererGL& add(AbstractShaper& shaper, Float size, Containers::StringView text); |
||||
RendererGL& add(AbstractShaper& shaper, Float size, Containers::StringView text, std::initializer_list<FeatureRange> features); |
||||
|
||||
Containers::Pair<Range2D, Range1Dui> render(AbstractShaper& shaper, Float size, Containers::StringView text, Containers::ArrayView<const FeatureRange> features); |
||||
Containers::Pair<Range2D, Range1Dui> render(AbstractShaper& shaper, Float size, Containers::StringView text); |
||||
Containers::Pair<Range2D, Range1Dui> render(AbstractShaper& shaper, Float size, Containers::StringView text, std::initializer_list<FeatureRange> features); |
||||
#endif |
||||
|
||||
private: |
||||
struct State; |
||||
}; |
||||
|
||||
}} |
||||
#else |
||||
#error this header is available only in the OpenGL build |
||||
#endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,74 @@
|
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
||||
2020, 2021, 2022, 2023, 2024, 2025 |
||||
Vladimír Vondruš <mosra@centrum.cz> |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a |
||||
copy of this software and associated documentation files (the "Software"), |
||||
to deal in the Software without restriction, including without limitation |
||||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||
and/or sell copies of the Software, and to permit persons to whom the |
||||
Software is furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included |
||||
in all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
DEALINGS IN THE SOFTWARE. |
||||
*/ |
||||
|
||||
#include <Corrade/Containers/String.h> |
||||
#include <Corrade/TestSuite/Tester.h> |
||||
|
||||
#include "Magnum/Text/RendererGL.h" |
||||
|
||||
namespace Magnum { namespace Text { namespace Test { namespace { |
||||
|
||||
struct RendererGL_Test: TestSuite::Tester { |
||||
explicit RendererGL_Test(); |
||||
|
||||
void debugFlag(); |
||||
void debugFlags(); |
||||
|
||||
void constructNoCreate(); |
||||
}; |
||||
|
||||
RendererGL_Test::RendererGL_Test() { |
||||
addTests({&RendererGL_Test::debugFlag, |
||||
&RendererGL_Test::debugFlags, |
||||
|
||||
&RendererGL_Test::constructNoCreate}); |
||||
} |
||||
|
||||
void RendererGL_Test::debugFlag() { |
||||
Containers::String out; |
||||
Debug{&out} << RendererGLFlag::GlyphPositionsClusters << RendererGLFlag(0xca); |
||||
CORRADE_COMPARE(out, "Text::RendererGLFlag::GlyphPositionsClusters Text::RendererGLFlag(0xca)\n"); |
||||
} |
||||
|
||||
void RendererGL_Test::debugFlags() { |
||||
Containers::String out; |
||||
Debug{&out} << (RendererGLFlag::GlyphPositionsClusters|RendererGLFlag(0xf0)) << RendererGLFlags{}; |
||||
CORRADE_COMPARE(out, "Text::RendererGLFlag::GlyphPositionsClusters|Text::RendererGLFlag(0xf0) Text::RendererGLFlags{}\n"); |
||||
} |
||||
|
||||
void RendererGL_Test::constructNoCreate() { |
||||
RendererGL renderer{NoCreate}; |
||||
|
||||
/* Shouldn't crash */ |
||||
CORRADE_VERIFY(true); |
||||
|
||||
/* Implicit construction is not allowed */ |
||||
CORRADE_VERIFY(!std::is_convertible<NoCreateT, RendererGL>::value); |
||||
} |
||||
|
||||
}}}} |
||||
|
||||
CORRADE_TEST_MAIN(Magnum::Text::Test::RendererGL_Test) |
||||
Binary file not shown.
Binary file not shown.
Loading…
Reference in new issue