Browse Source

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.
pull/34/head
Vladimír Vondruš 13 years ago
parent
commit
31dae6ef33
  1. 2
      src/Test/AbstractOpenGLTester.h
  2. 18
      src/Text/AbstractFont.h
  3. 9
      src/Text/CMakeLists.txt
  4. 4
      src/Text/GlyphCache.h
  5. 52
      src/Text/Renderer.cpp
  6. 281
      src/Text/Renderer.h
  7. 2
      src/Text/Test/CMakeLists.txt
  8. 28
      src/Text/Test/RendererGLTest.cpp
  9. 13
      src/Text/Text.h
  10. 276
      src/Text/TextRenderer.h

2
src/Test/AbstractOpenGLTester.h

@ -50,7 +50,7 @@ class AbstractOpenGLTester: public TestSuite::Tester, public Platform::Windowles
int AbstractOpenGLTester::zero = 0; int AbstractOpenGLTester::zero = 0;
#define MAGNUM_VERIFY_NO_ERROR() CORRADE_COMPARE(Renderer::error(), Renderer::Error::NoError) #define MAGNUM_VERIFY_NO_ERROR() CORRADE_COMPARE(Magnum::Renderer::error(), Magnum::Renderer::Error::NoError)
}} }}

18
src/Text/AbstractFont.h

@ -45,22 +45,22 @@ namespace Magnum { namespace Text {
@section AbstractFont-usage Usage @section AbstractFont-usage Usage
First step is to open the font using open(), next step is to prerender all the First step is to open the font using @ref open(), next step is to prerender all
glyphs which will be used in text rendering later, see GlyphCache for more the glyphs which will be used in text rendering later, see @ref GlyphCache for
information. See TextRenderer for information about text rendering. more information. See @ref Renderer for information about text rendering.
@section AbstractFont-subclassing Subclassing @section AbstractFont-subclassing Subclassing
Plugin implements doFeatures(), doClose(), doCreateGlyphCache(), doLayout() and Plugin implements @ref doFeatures(), @ref doClose(), @ref doCreateGlyphCache(),
one or more of `doOpen*()` functions. @ref doLayout() and one or more of `doOpen*()` functions.
You don't need to do most of the redundant sanity checks, these things are You don't need to do most of the redundant sanity checks, these things are
checked by the implementation: checked by the implementation:
- Functions doOpenData(), doOpenSingleData() and doOpenFile() are called - Functions @ref doOpenData(), @ref doOpenSingleData() and @ref doOpenFile()
after the previous file was closed, function doClose() is called only if are called after the previous file was closed, function @ref doClose() is
there is any file opened. called only if there is any file opened.
- Functions doOpenData() and doOpenSingleData() are called only if - Functions @ref doOpenData() and @ref doOpenSingleData() are called only if
@ref Feature::OpenData is supported. @ref Feature::OpenData is supported.
- All `do*()` implementations working on opened file are called only if - All `do*()` implementations working on opened file are called only if
there is any file opened. there is any file opened.

9
src/Text/CMakeLists.txt

@ -27,17 +27,22 @@ set(MagnumText_SRCS
AbstractFontConverter.cpp AbstractFontConverter.cpp
DistanceFieldGlyphCache.cpp DistanceFieldGlyphCache.cpp
GlyphCache.cpp GlyphCache.cpp
TextRenderer.cpp) Renderer.cpp)
set(MagnumText_HEADERS set(MagnumText_HEADERS
AbstractFont.h AbstractFont.h
AbstractFontConverter.h AbstractFontConverter.h
DistanceFieldGlyphCache.h DistanceFieldGlyphCache.h
GlyphCache.h GlyphCache.h
Renderer.h
Text.h Text.h
TextRenderer.h
magnumTextVisibility.h) magnumTextVisibility.h)
if(MAGNUM_BUILD_DEPRECATED)
set(MagnumText_HEADERS ${MagnumText_HEADERS}
TextRenderer.h)
endif()
add_library(MagnumText ${SHARED_OR_STATIC} ${MagnumText_SRCS}) add_library(MagnumText ${SHARED_OR_STATIC} ${MagnumText_SRCS})
if(BUILD_STATIC_PIC) if(BUILD_STATIC_PIC)
# TODO: CMake 2.8.9 has this as POSITION_INDEPENDENT_CODE property # TODO: CMake 2.8.9 has this as POSITION_INDEPENDENT_CODE property

4
src/Text/GlyphCache.h

@ -45,7 +45,7 @@ Contains font glyphs prerendered into texture atlas.
@section GlyphCache-usage Usage @section GlyphCache-usage Usage
Create %GlyphCache object with sufficient size and then call Create %GlyphCache object with sufficient size and then call
AbstractFont::createGlyphCache() to fill it with glyphs. @ref AbstractFont::createGlyphCache() to fill it with glyphs.
@code @code
Text::AbstractFont* font; Text::AbstractFont* font;
Text::GlyphCache* cache = new GlyphCache(Vector2i(512)); Text::GlyphCache* cache = new GlyphCache(Vector2i(512));
@ -54,7 +54,7 @@ font->createGlyphCache(cache, "abcdefghijklmnopqrstuvwxyz"
"0123456789 "); "0123456789 ");
@endcode @endcode
See TextRenderer for information about text rendering. See @ref Renderer for information about text rendering.
@todo Some way for Font to negotiate or check internal texture format @todo Some way for Font to negotiate or check internal texture format
@todo Default glyph 0 with rect 0 0 0 0 will result in negative dimensions when @todo Default glyph 0 with rect 0 0 0 0 will result in negative dimensions when
nonzero padding is removed nonzero padding is removed

52
src/Text/TextRenderer.cpp → src/Text/Renderer.cpp

@ -22,7 +22,7 @@
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include "TextRenderer.h" #include "Renderer.h"
#include "Context.h" #include "Context.h"
#include "Extensions.h" #include "Extensions.h"
@ -60,7 +60,7 @@ struct Vertex {
} }
std::tuple<std::vector<Vector2>, std::vector<Vector2>, std::vector<UnsignedInt>, Rectangle> AbstractTextRenderer::render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text) { std::tuple<std::vector<Vector2>, std::vector<Vector2>, std::vector<UnsignedInt>, Rectangle> AbstractRenderer::render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text) {
const auto layouter = font.layout(cache, size, text); const auto layouter = font.layout(cache, size, text);
const UnsignedInt vertexCount = layouter->glyphCount()*4; const UnsignedInt vertexCount = layouter->glyphCount()*4;
@ -118,7 +118,7 @@ std::tuple<std::vector<Vector2>, std::vector<Vector2>, std::vector<UnsignedInt>,
return std::make_tuple(std::move(positions), std::move(texcoords), std::move(indices), rectangle); return std::make_tuple(std::move(positions), std::move(texcoords), std::move(indices), rectangle);
} }
std::tuple<Mesh, Rectangle> AbstractTextRenderer::render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage) { std::tuple<Mesh, Rectangle> AbstractRenderer::render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage) {
const auto layouter = font.layout(cache, size, text); const auto layouter = font.layout(cache, size, text);
const UnsignedInt vertexCount = layouter->glyphCount()*4; const UnsignedInt vertexCount = layouter->glyphCount()*4;
@ -192,9 +192,9 @@ std::tuple<Mesh, Rectangle> AbstractTextRenderer::render(AbstractFont& font, con
return std::make_tuple(std::move(mesh), rectangle); return std::make_tuple(std::move(mesh), rectangle);
} }
template<UnsignedInt dimensions> std::tuple<Mesh, Rectangle> TextRenderer<dimensions>::render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage) { template<UnsignedInt dimensions> std::tuple<Mesh, Rectangle> Renderer<dimensions>::render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage) {
/* Finalize mesh configuration and return the result */ /* Finalize mesh configuration and return the result */
auto r = AbstractTextRenderer::render(font, cache, size, text, vertexBuffer, indexBuffer, usage); auto r = AbstractRenderer::render(font, cache, size, text, vertexBuffer, indexBuffer, usage);
Mesh& mesh = std::get<0>(r); Mesh& mesh = std::get<0>(r);
mesh.addVertexBuffer(vertexBuffer, 0, mesh.addVertexBuffer(vertexBuffer, 0,
typename Shaders::AbstractVector<dimensions>::Position( typename Shaders::AbstractVector<dimensions>::Position(
@ -204,26 +204,26 @@ template<UnsignedInt dimensions> std::tuple<Mesh, Rectangle> TextRenderer<dimens
} }
#if defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN) #if defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN)
AbstractTextRenderer::BufferMapImplementation AbstractTextRenderer::bufferMapImplementation = &AbstractTextRenderer::bufferMapImplementationFull; AbstractRenderer::BufferMapImplementation AbstractRenderer::bufferMapImplementation = &AbstractRenderer::bufferMapImplementationFull;
AbstractTextRenderer::BufferUnmapImplementation AbstractTextRenderer::bufferUnmapImplementation = &AbstractTextRenderer::bufferUnmapImplementationDefault; AbstractRenderer::BufferUnmapImplementation AbstractRenderer::bufferUnmapImplementation = &AbstractRenderer::bufferUnmapImplementationDefault;
void* AbstractTextRenderer::bufferMapImplementationFull(Buffer& buffer, GLsizeiptr) { void* AbstractRenderer::bufferMapImplementationFull(Buffer& buffer, GLsizeiptr) {
return buffer.map(Buffer::MapAccess::WriteOnly); return buffer.map(Buffer::MapAccess::WriteOnly);
} }
void* AbstractTextRenderer::bufferMapImplementationSub(Buffer& buffer, GLsizeiptr length) { void* AbstractRenderer::bufferMapImplementationSub(Buffer& buffer, GLsizeiptr length) {
return buffer.mapSub(0, length, Buffer::MapAccess::WriteOnly); return buffer.mapSub(0, length, Buffer::MapAccess::WriteOnly);
} }
void AbstractTextRenderer::bufferUnmapImplementationSub(Buffer& buffer) { void AbstractRenderer::bufferUnmapImplementationSub(Buffer& buffer) {
buffer.unmapSub(); buffer.unmapSub();
} }
#endif #endif
#if !defined(MAGNUM_TARGET_GLES2) || defined(CORRADE_TARGET_EMSCRIPTEN) #if !defined(MAGNUM_TARGET_GLES2) || defined(CORRADE_TARGET_EMSCRIPTEN)
inline void* AbstractTextRenderer::bufferMapImplementation(Buffer& buffer, GLsizeiptr length) inline void* AbstractRenderer::bufferMapImplementation(Buffer& buffer, GLsizeiptr length)
#else #else
void* AbstractTextRenderer::bufferMapImplementationRange(Buffer& buffer, GLsizeiptr length) void* AbstractRenderer::bufferMapImplementationRange(Buffer& buffer, GLsizeiptr length)
#endif #endif
{ {
#ifndef CORRADE_TARGET_EMSCRIPTEN #ifndef CORRADE_TARGET_EMSCRIPTEN
@ -235,9 +235,9 @@ void* AbstractTextRenderer::bufferMapImplementationRange(Buffer& buffer, GLsizei
} }
#if !defined(MAGNUM_TARGET_GLES2) || defined(CORRADE_TARGET_EMSCRIPTEN) #if !defined(MAGNUM_TARGET_GLES2) || defined(CORRADE_TARGET_EMSCRIPTEN)
inline void AbstractTextRenderer::bufferUnmapImplementation(Buffer& buffer) inline void AbstractRenderer::bufferUnmapImplementation(Buffer& buffer)
#else #else
void AbstractTextRenderer::bufferUnmapImplementationDefault(Buffer& buffer) void AbstractRenderer::bufferUnmapImplementationDefault(Buffer& buffer)
#endif #endif
{ {
#ifndef CORRADE_TARGET_EMSCRIPTEN #ifndef CORRADE_TARGET_EMSCRIPTEN
@ -247,18 +247,18 @@ void AbstractTextRenderer::bufferUnmapImplementationDefault(Buffer& buffer)
#endif #endif
} }
AbstractTextRenderer::AbstractTextRenderer(AbstractFont& font, const GlyphCache& cache, Float size): _vertexBuffer(Buffer::Target::Array), _indexBuffer(Buffer::Target::ElementArray), font(font), cache(cache), size(size), _capacity(0) { AbstractRenderer::AbstractRenderer(AbstractFont& font, const GlyphCache& cache, Float size): _vertexBuffer(Buffer::Target::Array), _indexBuffer(Buffer::Target::ElementArray), font(font), cache(cache), size(size), _capacity(0) {
#ifndef MAGNUM_TARGET_GLES #ifndef MAGNUM_TARGET_GLES
MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::ARB::map_buffer_range); MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::ARB::map_buffer_range);
#elif defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN) #elif defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN)
if(Context::current()->isExtensionSupported<Extensions::GL::EXT::map_buffer_range>()) { if(Context::current()->isExtensionSupported<Extensions::GL::EXT::map_buffer_range>()) {
bufferMapImplementation = &AbstractTextRenderer::bufferMapImplementationRange; bufferMapImplementation = &AbstractRenderer::bufferMapImplementationRange;
} else if(Context::current()->isExtensionSupported<Extensions::GL::CHROMIUM::map_sub>()) { } else if(Context::current()->isExtensionSupported<Extensions::GL::CHROMIUM::map_sub>()) {
bufferMapImplementation = &AbstractTextRenderer::bufferMapImplementationSub; bufferMapImplementation = &AbstractRenderer::bufferMapImplementationSub;
bufferUnmapImplementation = &AbstractTextRenderer::bufferUnmapImplementationSub; bufferUnmapImplementation = &AbstractRenderer::bufferUnmapImplementationSub;
} else { } else {
MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::OES::mapbuffer); MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::OES::mapbuffer);
Warning() << "Text::TextRenderer: neither" << Extensions::GL::EXT::map_buffer_range::string() Warning() << "Text::Renderer: neither" << Extensions::GL::EXT::map_buffer_range::string()
<< "nor" << Extensions::GL::CHROMIUM::map_sub::string() << "nor" << Extensions::GL::CHROMIUM::map_sub::string()
<< "is supported, using inefficient" << Extensions::GL::OES::mapbuffer::string() << "is supported, using inefficient" << Extensions::GL::OES::mapbuffer::string()
<< "instead"; << "instead";
@ -269,16 +269,16 @@ AbstractTextRenderer::AbstractTextRenderer(AbstractFont& font, const GlyphCache&
_mesh.setPrimitive(Mesh::Primitive::Triangles); _mesh.setPrimitive(Mesh::Primitive::Triangles);
} }
AbstractTextRenderer::~AbstractTextRenderer() {} AbstractRenderer::~AbstractRenderer() {}
template<UnsignedInt dimensions> TextRenderer<dimensions>::TextRenderer(AbstractFont& font, const GlyphCache& cache, const Float size): AbstractTextRenderer(font, cache, size) { template<UnsignedInt dimensions> Renderer<dimensions>::Renderer(AbstractFont& font, const GlyphCache& cache, const Float size): AbstractRenderer(font, cache, size) {
/* Finalize mesh configuration */ /* Finalize mesh configuration */
_mesh.addVertexBuffer(_vertexBuffer, 0, _mesh.addVertexBuffer(_vertexBuffer, 0,
typename Shaders::AbstractVector<dimensions>::Position(Shaders::AbstractVector<dimensions>::Position::Components::Two), typename Shaders::AbstractVector<dimensions>::Position(Shaders::AbstractVector<dimensions>::Position::Components::Two),
typename Shaders::AbstractVector<dimensions>::TextureCoordinates()); typename Shaders::AbstractVector<dimensions>::TextureCoordinates());
} }
void AbstractTextRenderer::reserve(const uint32_t glyphCount, const Buffer::Usage vertexBufferUsage, const Buffer::Usage indexBufferUsage) { void AbstractRenderer::reserve(const uint32_t glyphCount, const Buffer::Usage vertexBufferUsage, const Buffer::Usage indexBufferUsage) {
_capacity = glyphCount; _capacity = glyphCount;
const UnsignedInt vertexCount = glyphCount*4; const UnsignedInt vertexCount = glyphCount*4;
@ -325,11 +325,11 @@ void AbstractTextRenderer::reserve(const uint32_t glyphCount, const Buffer::Usag
bufferUnmapImplementation(_indexBuffer); bufferUnmapImplementation(_indexBuffer);
} }
void AbstractTextRenderer::render(const std::string& text) { void AbstractRenderer::render(const std::string& text) {
const auto layouter = font.layout(cache, size, text); const auto layouter = font.layout(cache, size, text);
CORRADE_ASSERT(layouter->glyphCount() <= _capacity, CORRADE_ASSERT(layouter->glyphCount() <= _capacity,
"Text::TextRenderer::render(): capacity" << _capacity << "too small to render" << layouter->glyphCount() << "glyphs", ); "Text::Renderer::render(): capacity" << _capacity << "too small to render" << layouter->glyphCount() << "glyphs", );
/* Reset rendered rectangle */ /* Reset rendered rectangle */
_rectangle = {}; _rectangle = {};
@ -371,8 +371,8 @@ void AbstractTextRenderer::render(const std::string& text) {
} }
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template class MAGNUM_TEXT_EXPORT TextRenderer<2>; template class MAGNUM_TEXT_EXPORT Renderer<2>;
template class MAGNUM_TEXT_EXPORT TextRenderer<3>; template class MAGNUM_TEXT_EXPORT Renderer<3>;
#endif #endif
}} }}

281
src/Text/Renderer.h

@ -0,0 +1,281 @@
#ifndef Magnum_Text_Renderer_h
#define Magnum_Text_Renderer_h
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013 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::AbstractRenderer, @ref Magnum::Text::Renderer, typedef @ref Magnum::Text::Renderer2D, @ref Magnum::Text::Renderer3D
*/
#include "Math/Geometry/Rectangle.h"
#include "Buffer.h"
#include "DimensionTraits.h"
#include "Mesh.h"
#include "Text/Text.h"
#include "magnumTextVisibility.h"
#include <string>
#include <tuple>
#include <vector>
namespace Magnum { namespace Text {
/**
@brief Base for text renderers
Not meant to be used directly, see @ref Renderer for more information.
@see @ref Renderer2D, @ref Renderer3D
*/
class MAGNUM_TEXT_EXPORT AbstractRenderer {
public:
/**
* @brief Render text
* @param font Font
* @param cache Glyph cache
* @param size Font size
* @param text Text to render
*
* Returns tuple with vertex positions, texture coordinates, indices
* and rectangle spanning the rendered text.
*/
static std::tuple<std::vector<Vector2>, std::vector<Vector2>, std::vector<UnsignedInt>, Rectangle> render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text);
/**
* @brief Capacity for rendered glyphs
*
* @see @ref reserve()
*/
UnsignedInt capacity() const { return _capacity; }
/** @brief Rectangle spanning the rendered text */
Rectangle rectangle() const { return _rectangle; }
/** @brief Vertex buffer */
Buffer& vertexBuffer() { return _vertexBuffer; }
/** @brief Index buffer */
Buffer& indexBuffer() { return _indexBuffer; }
/** @brief Mesh */
Mesh& mesh() { return _mesh; }
/**
* @brief Reserve capacity for rendered glyphs
*
* Reallocates memory in buffers to hold @p glyphCount glyphs and
* prefills index buffer. Consider using appropriate @p vertexBufferUsage
* if the text will be changed frequently. Index buffer is changed
* only by calling this function, thus @p indexBufferUsage generally
* doesn't need to be so dynamic if the capacity won't be changed much.
*
* Initially zero capacity is reserved.
* @see @ref capacity()
*/
void reserve(UnsignedInt glyphCount, Buffer::Usage vertexBufferUsage, Buffer::Usage indexBufferUsage);
/**
* @brief Render text
*
* Renders the text to vertex buffer, reusing index buffer already
* filled with @ref reserve(). Rectangle spanning the rendered text is
* available through @ref rectangle().
*
* Initially no text is rendered.
* @attention The capacity must be large enough to contain all glyphs,
* see @ref reserve() for more information.
*/
void render(const std::string& text);
protected:
/**
* @brief Constructor
* @param font Font
* @param cache Glyph cache
* @param size Font size
*/
explicit AbstractRenderer(AbstractFont& font, const GlyphCache& cache, Float size);
AbstractRenderer(AbstractFont&, GlyphCache&&, Float) = delete; /**< @overload */
~AbstractRenderer();
#ifndef DOXYGEN_GENERATING_OUTPUT
protected:
#else
private:
#endif
static std::tuple<Mesh, Rectangle> MAGNUM_LOCAL render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage);
Mesh _mesh;
Buffer _vertexBuffer, _indexBuffer;
#ifdef CORRADE_TARGET_EMSCRIPTEN
Containers::Array<UnsignedByte> _vertexBufferData, _indexBufferData;
#endif
private:
AbstractFont& font;
const GlyphCache& cache;
Float size;
UnsignedInt _capacity;
Rectangle _rectangle;
#if defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN)
typedef void*(*BufferMapImplementation)(Buffer&, GLsizeiptr);
static MAGNUM_TEXT_LOCAL void* bufferMapImplementationFull(Buffer& buffer, GLsizeiptr length);
static MAGNUM_TEXT_LOCAL void* bufferMapImplementationSub(Buffer& buffer, GLsizeiptr length);
static MAGNUM_TEXT_LOCAL void* bufferMapImplementationRange(Buffer& buffer, GLsizeiptr length);
static BufferMapImplementation bufferMapImplementation;
#else
#ifndef CORRADE_TARGET_EMSCRIPTEN
static
#else
MAGNUM_TEXT_LOCAL
#endif
void* bufferMapImplementation(Buffer& buffer, GLsizeiptr length);
#endif
#if defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN)
typedef void(*BufferUnmapImplementation)(Buffer&);
static MAGNUM_TEXT_LOCAL void bufferUnmapImplementationDefault(Buffer& buffer);
static MAGNUM_TEXT_LOCAL void bufferUnmapImplementationSub(Buffer& buffer);
static MAGNUM_TEXT_LOCAL BufferUnmapImplementation bufferUnmapImplementation;
#else
#ifndef CORRADE_TARGET_EMSCRIPTEN
static
#else
MAGNUM_TEXT_LOCAL
#endif
void bufferUnmapImplementation(Buffer& buffer);
#endif
};
/**
@brief %Text renderer
Lays out the text into mesh using given font. Use of ligatures, kerning etc.
depends on features supported by particular font and its layouter.
@section Renderer-usage Usage
Immutable text (e.g. menu items, credits) can be simply rendered using static
methods, returning result either as data arrays or as fully configured mesh.
The text can be then drawn by configuring text shader, binding font texture
and drawing the mesh:
@code
Text::AbstractFont* font;
Text::GlyphCache cache;
Shaders::VectorShader2D shader;
Buffer vertexBuffer, indexBuffer;
Mesh mesh;
// Render the text
Rectangle rectangle;
std::tie(mesh, rectangle) = Text::Renderer2D::render(*font, cache, 0.15f,
"Hello World!", vertexBuffer, indexBuffer, Buffer::Usage::StaticDraw);
// Draw white text centered on the screen
shader.setTransformationProjectionMatrix(projection*Matrix3::translation(-rectangle.width()/2.0f))
.setColor(Color3(1.0f));
.use();
glyphCache->texture()->bind(Shaders::VectorShader2D::FontTextureLayer);
mesh.draw();
@endcode
See @ref render(AbstractFont&, const GlyphCache&, Float, const std::string&) and
@ref render(AbstractFont&, const GlyphCache&, Float, const std::string&, Buffer&, Buffer&, Buffer::Usage)
for more information.
While this method is sufficient for one-shot rendering of static texts, for
mutable texts (e.g. FPS counters, chat messages) there is another approach
that doesn't recreate everything on each text change:
@code
Text::AbstractFont* font;
Text::GlyphCache cache;
Shaders::VectorShader2D shader;
// Initialize renderer and reserve memory for enough glyphs
Text::Renderer2D renderer(*font, cache, 0.15f);
renderer.reserve(32, Buffer::Usage::DynamicDraw, Buffer::Usage::StaticDraw);
// Update the text occasionally
renderer.render("Hello World Countdown: 10");
// Draw the text centered on the screen
shader.setTransformationProjectionMatrix(projection*Matrix3::translation(-renderer.rectangle().width()/2.0f))
.setColor(Color3(1.0f));
.use();
glyphCache->texture()->bind(Shaders::VectorShader2D::FontTextureLayer);
renderer.mesh().draw();
@endcode
@section Renderer-extensions Required OpenGL functionality
Mutable text rendering requires @extension{ARB,map_buffer_range} on desktop
OpenGL (also part of OpenGL ES 3.0). If neither @es_extension{EXT,map_buffer_range}
nor @es_extension{CHROMIUM,map_sub} is not available in ES 2.0, at least
@es_extension{OES,mapbuffer} must be supported for asynchronous buffer updates.
There is no similar extension in WebGL, thus plain (and slow) buffer updates
are used there.
@see @ref Renderer2D, @ref Renderer3D, @ref AbstractFont,
@ref Shaders::AbstractVector
*/
template<UnsignedInt dimensions> class MAGNUM_TEXT_EXPORT Renderer: public AbstractRenderer {
public:
/**
* @brief Render text
* @param font Font
* @param cache Glyph cache
* @param size Font size
* @param text %Text to render
* @param vertexBuffer %Buffer where to store vertices
* @param indexBuffer %Buffer where to store indices
* @param usage Usage of vertex and index buffer
*
* Returns mesh prepared for use with @ref Shaders::AbstractVector
* subclasses and rectangle spanning the rendered text.
*/
static std::tuple<Mesh, Rectangle> render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage);
/**
* @brief Constructor
* @param font Font
* @param cache Glyph cache
* @param size Font size
*/
explicit Renderer(AbstractFont& font, const GlyphCache& cache, Float size);
Renderer(AbstractFont&, GlyphCache&&, Float) = delete; /**< @overload */
using AbstractRenderer::render;
};
/** @brief Two-dimensional text renderer */
typedef Renderer<2> Renderer2D;
/** @brief Three-dimensional text renderer */
typedef Renderer<3> Renderer3D;
}}
#endif

2
src/Text/Test/CMakeLists.txt

@ -32,5 +32,5 @@ corrade_add_test(TextAbstractFontConverterTest AbstractFontConverterTest.cpp LIB
if(BUILD_GL_TESTS) if(BUILD_GL_TESTS)
corrade_add_test(TextGlyphCacheGLTest GlyphCacheGLTest.cpp LIBRARIES MagnumText ${GL_TEST_LIBRARIES}) corrade_add_test(TextGlyphCacheGLTest GlyphCacheGLTest.cpp LIBRARIES MagnumText ${GL_TEST_LIBRARIES})
corrade_add_test(TextRendererGLTest TextRendererGLTest.cpp LIBRARIES MagnumText ${GL_TEST_LIBRARIES}) corrade_add_test(TextRendererGLTest RendererGLTest.cpp LIBRARIES MagnumText ${GL_TEST_LIBRARIES})
endif() endif()

28
src/Text/Test/TextRendererGLTest.cpp → src/Text/Test/RendererGLTest.cpp

@ -24,23 +24,23 @@
#include "Test/AbstractOpenGLTester.h" #include "Test/AbstractOpenGLTester.h"
#include "Text/AbstractFont.h" #include "Text/AbstractFont.h"
#include "Text/TextRenderer.h" #include "Text/Renderer.h"
namespace Magnum { namespace Text { namespace Test { namespace Magnum { namespace Text { namespace Test {
class TextRendererGLTest: public Magnum::Test::AbstractOpenGLTester { class RendererGLTest: public Magnum::Test::AbstractOpenGLTester {
public: public:
explicit TextRendererGLTest(); explicit RendererGLTest();
void renderData(); void renderData();
void renderMesh(); void renderMesh();
void mutableText(); void mutableText();
}; };
TextRendererGLTest::TextRendererGLTest() { RendererGLTest::RendererGLTest() {
addTests({&TextRendererGLTest::renderData, addTests({&RendererGLTest::renderData,
&TextRendererGLTest::renderMesh, &RendererGLTest::renderMesh,
&TextRendererGLTest::mutableText}); &RendererGLTest::mutableText});
} }
namespace { namespace {
@ -80,13 +80,13 @@ class TestFont: public Text::AbstractFont {
} }
void TextRendererGLTest::renderData() { void RendererGLTest::renderData() {
TestFont font; TestFont font;
std::vector<Vector2> positions; std::vector<Vector2> positions;
std::vector<Vector2> textureCoordinates; std::vector<Vector2> textureCoordinates;
std::vector<UnsignedInt> indices; std::vector<UnsignedInt> indices;
Rectangle bounds; Rectangle bounds;
std::tie(positions, textureCoordinates, indices, bounds) = Text::AbstractTextRenderer::render(font, *static_cast<GlyphCache*>(nullptr), 0.25f, "abc"); std::tie(positions, textureCoordinates, indices, bounds) = Text::AbstractRenderer::render(font, *static_cast<GlyphCache*>(nullptr), 0.25f, "abc");
/* Three glyphs, three quads -> 12 vertices, 18 indices */ /* Three glyphs, three quads -> 12 vertices, 18 indices */
CORRADE_COMPARE(positions.size(), 12); CORRADE_COMPARE(positions.size(), 12);
@ -160,12 +160,12 @@ void TextRendererGLTest::renderData() {
CORRADE_COMPARE(bounds, Rectangle({0.0f, -0.5f}, {5.0f, 1.0f})); CORRADE_COMPARE(bounds, Rectangle({0.0f, -0.5f}, {5.0f, 1.0f}));
} }
void TextRendererGLTest::renderMesh() { void RendererGLTest::renderMesh() {
TestFont font; TestFont font;
Mesh mesh; Mesh mesh;
Buffer vertexBuffer, indexBuffer; Buffer vertexBuffer, indexBuffer;
Rectangle bounds; Rectangle bounds;
std::tie(mesh, bounds) = Text::TextRenderer3D::render(font, *static_cast<GlyphCache*>(nullptr), 0.25f, "abc", vertexBuffer, indexBuffer, Buffer::Usage::StaticDraw); std::tie(mesh, bounds) = Text::Renderer3D::render(font, *static_cast<GlyphCache*>(nullptr), 0.25f, "abc", vertexBuffer, indexBuffer, Buffer::Usage::StaticDraw);
MAGNUM_VERIFY_NO_ERROR(); MAGNUM_VERIFY_NO_ERROR();
/** @todo How to verify this on ES? */ /** @todo How to verify this on ES? */
@ -201,9 +201,9 @@ void TextRendererGLTest::renderMesh() {
CORRADE_COMPARE(bounds, Rectangle({0.0f, -0.5f}, {5.0f, 1.0f})); CORRADE_COMPARE(bounds, Rectangle({0.0f, -0.5f}, {5.0f, 1.0f}));
} }
void TextRendererGLTest::mutableText() { void RendererGLTest::mutableText() {
TestFont font; TestFont font;
Text::TextRenderer2D renderer(font, *static_cast<GlyphCache*>(nullptr), 0.25f); Text::Renderer2D renderer(font, *static_cast<GlyphCache*>(nullptr), 0.25f);
MAGNUM_VERIFY_NO_ERROR(); MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(renderer.capacity(), 0); CORRADE_COMPARE(renderer.capacity(), 0);
CORRADE_COMPARE(renderer.rectangle(), Rectangle()); CORRADE_COMPARE(renderer.rectangle(), Rectangle());
@ -253,4 +253,4 @@ void TextRendererGLTest::mutableText() {
}}} }}}
CORRADE_TEST_MAIN(Magnum::Text::Test::TextRendererGLTest) CORRADE_TEST_MAIN(Magnum::Text::Test::RendererGLTest)

13
src/Text/Text.h

@ -40,10 +40,15 @@ class AbstractLayouter;
class DistanceFieldGlyphCache; class DistanceFieldGlyphCache;
class GlyphCache; class GlyphCache;
class AbstractTextRenderer; class AbstractRenderer;
template<UnsignedInt> class TextRenderer; template<UnsignedInt> class Renderer;
typedef TextRenderer<2> TextRenderer2D; typedef Renderer<2> Renderer2D;
typedef TextRenderer<3> TextRenderer3D; typedef Renderer<3> Renderer3D;
#ifdef MAGNUM_BUILD_DEPRECATED
typedef Renderer<2> TextRenderer2D;
typedef Renderer<3> TextRenderer3D;
#endif
}} }}

276
src/Text/TextRenderer.h

@ -1,279 +1,25 @@
#ifndef Magnum_Text_TextRenderer_h #ifndef Magnum_Text_TextRenderer_h
#define Magnum_Text_TextRenderer_h #define Magnum_Text_TextRenderer_h
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013 Vladimír Vondruš <mosra@centrum.cz> #include "Text/Renderer.h"
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 Magnum::Text::AbstractTextRenderer, Magnum::Text::TextRenderer, typedef Magnum::Text::TextRenderer2D, Magnum::Text::TextRenderer3D
*/
#include "Math/Geometry/Rectangle.h"
#include "Buffer.h"
#include "DimensionTraits.h"
#include "Mesh.h"
#include "Text/Text.h"
#include "magnumTextVisibility.h"
#include <string>
#include <tuple>
#include <vector>
namespace Magnum { namespace Text { namespace Magnum { namespace Text {
#ifdef MAGNUM_BUILD_DEPRECATED
/** /**
@brief Base for text renderers @copybrief Renderer2D
@deprecated Use @ref Magnum::Text::Renderer2D "Renderer2D" instead.
Not meant to be used directly, see TextRenderer for more information.
@see TextRenderer2D, TextRenderer3D
*/ */
class MAGNUM_TEXT_EXPORT AbstractTextRenderer { typedef Renderer<2> TextRenderer2D;
public:
/**
* @brief Render text
* @param font Font
* @param cache Glyph cache
* @param size Font size
* @param text Text to render
*
* Returns tuple with vertex positions, texture coordinates, indices
* and rectangle spanning the rendered text.
*/
static std::tuple<std::vector<Vector2>, std::vector<Vector2>, std::vector<UnsignedInt>, Rectangle> render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text);
/**
* @brief Capacity for rendered glyphs
*
* @see reserve()
*/
UnsignedInt capacity() const { return _capacity; }
/** @brief Rectangle spanning the rendered text */
Rectangle rectangle() const { return _rectangle; }
/** @brief Vertex buffer */
Buffer& vertexBuffer() { return _vertexBuffer; }
/** @brief Index buffer */
Buffer& indexBuffer() { return _indexBuffer; }
/** @brief Mesh */
Mesh& mesh() { return _mesh; }
/**
* @brief Reserve capacity for rendered glyphs
*
* Reallocates memory in buffers to hold @p glyphCount glyphs and
* prefills index buffer. Consider using appropriate @p vertexBufferUsage
* if the text will be changed frequently. Index buffer is changed
* only by calling this function, thus @p indexBufferUsage generally
* doesn't need to be so dynamic if the capacity won't be changed much.
*
* Initially zero capacity is reserved.
* @see capacity()
*/
void reserve(UnsignedInt glyphCount, Buffer::Usage vertexBufferUsage, Buffer::Usage indexBufferUsage);
/**
* @brief Render text
*
* Renders the text to vertex buffer, reusing index buffer already
* filled with reserve(). Rectangle spanning the rendered text is
* available through rectangle().
*
* Initially no text is rendered.
* @attention The capacity must be large enough to contain all glyphs,
* see reserve() for more information.
*/
void render(const std::string& text);
protected:
/**
* @brief Constructor
* @param font Font
* @param cache Glyph cache
* @param size Font size
*/
explicit AbstractTextRenderer(AbstractFont& font, const GlyphCache& cache, Float size);
AbstractTextRenderer(AbstractFont&, GlyphCache&&, Float) = delete; /**< @overload */
~AbstractTextRenderer();
#ifndef DOXYGEN_GENERATING_OUTPUT
protected:
#else
private:
#endif
static std::tuple<Mesh, Rectangle> MAGNUM_LOCAL render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage);
Mesh _mesh;
Buffer _vertexBuffer, _indexBuffer;
#ifdef CORRADE_TARGET_EMSCRIPTEN
Containers::Array<UnsignedByte> _vertexBufferData, _indexBufferData;
#endif
private:
AbstractFont& font;
const GlyphCache& cache;
Float size;
UnsignedInt _capacity;
Rectangle _rectangle;
#if defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN)
typedef void*(*BufferMapImplementation)(Buffer&, GLsizeiptr);
static MAGNUM_TEXT_LOCAL void* bufferMapImplementationFull(Buffer& buffer, GLsizeiptr length);
static MAGNUM_TEXT_LOCAL void* bufferMapImplementationSub(Buffer& buffer, GLsizeiptr length);
static MAGNUM_TEXT_LOCAL void* bufferMapImplementationRange(Buffer& buffer, GLsizeiptr length);
static BufferMapImplementation bufferMapImplementation;
#else
#ifndef CORRADE_TARGET_EMSCRIPTEN
static
#else
MAGNUM_TEXT_LOCAL
#endif
void* bufferMapImplementation(Buffer& buffer, GLsizeiptr length);
#endif
#if defined(MAGNUM_TARGET_GLES2) && !defined(CORRADE_TARGET_EMSCRIPTEN)
typedef void(*BufferUnmapImplementation)(Buffer&);
static MAGNUM_TEXT_LOCAL void bufferUnmapImplementationDefault(Buffer& buffer);
static MAGNUM_TEXT_LOCAL void bufferUnmapImplementationSub(Buffer& buffer);
static MAGNUM_TEXT_LOCAL BufferUnmapImplementation bufferUnmapImplementation;
#else
#ifndef CORRADE_TARGET_EMSCRIPTEN
static
#else
MAGNUM_TEXT_LOCAL
#endif
void bufferUnmapImplementation(Buffer& buffer);
#endif
};
/** /**
@brief %Text renderer @copybrief Renderer3D
@deprecated Use @ref Magnum::Text::Renderer3D "Renderer3D" instead.
Lays out the text into mesh using given Font. Use of ligatures, kerning etc.
depends on features supported by particular font and its layouter.
@section TextRenderer-usage Usage
Immutable text (e.g. menu items, credits) can be simply rendered using static
methods, returning result either as data arrays or as fully configured mesh.
The text can be then drawn by configuring text shader, binding font texture
and drawing the mesh:
@code
Text::AbstractFont* font;
Text::GlyphCache cache;
Shaders::VectorShader2D shader;
Buffer vertexBuffer, indexBuffer;
Mesh mesh;
// Render the text
Rectangle rectangle;
std::tie(mesh, rectangle) = Text::TextRenderer2D::render(*font, cache, 0.15f,
"Hello World!", vertexBuffer, indexBuffer, Buffer::Usage::StaticDraw);
// Draw white text centered on the screen
shader.setTransformationProjectionMatrix(projection*Matrix3::translation(-rectangle.width()/2.0f))
.setColor(Color3(1.0f));
.use();
glyphCache->texture()->bind(Shaders::VectorShader2D::FontTextureLayer);
mesh.draw();
@endcode
See render(Font* const, const GlyphCache* const, Float, const std::string&) and
render(Font* const, const GlyphCache* const, Float, const std::string&, Buffer*, Buffer*, Buffer::Usage)
for more information.
While this method is sufficient for one-shot rendering of static texts, for
mutable texts (e.g. FPS counters, chat messages) there is another approach
that doesn't recreate everything on each text change:
@code
Text::AbstractFont* font;
Text::GlyphCache cache;
Shaders::VectorShader2D shader;
// Initialize renderer and reserve memory for enough glyphs
Text::TextRenderer2D renderer(*font, cache, 0.15f);
renderer.reserve(32, Buffer::Usage::DynamicDraw, Buffer::Usage::StaticDraw);
// Update the text occasionally
renderer.render("Hello World Countdown: 10");
// Draw the text centered on the screen
shader.setTransformationProjectionMatrix(projection*Matrix3::translation(-renderer.rectangle().width()/2.0f))
.setColor(Color3(1.0f));
.use();
glyphCache->texture()->bind(Shaders::VectorShader2D::FontTextureLayer);
renderer.mesh().draw();
@endcode
@section TextRenderer-extensions Required OpenGL functionality
Mutable text rendering requires @extension{ARB,map_buffer_range} on desktop
OpenGL (also part of OpenGL ES 3.0). If neither @es_extension{EXT,map_buffer_range}
nor @es_extension{CHROMIUM,map_sub} is not available in ES 2.0, at least
@es_extension{OES,mapbuffer} must be supported for asynchronous buffer updates.
There is no similar extension in WebGL, thus plain (and slow) buffer updates
are used there.
@see TextRenderer2D, TextRenderer3D, Font, Shaders::AbstractVectorShader
*/ */
template<UnsignedInt dimensions> class MAGNUM_TEXT_EXPORT TextRenderer: public AbstractTextRenderer { typedef Renderer<3> TextRenderer3D;
public: #else
/** #error
* @brief Render text #endif
* @param font Font
* @param cache Glyph cache
* @param size Font size
* @param text %Text to render
* @param vertexBuffer %Buffer where to store vertices
* @param indexBuffer %Buffer where to store indices
* @param usage Usage of vertex and index buffer
*
* Returns mesh prepared for use with Shaders::AbstractVectorShader
* subclasses and rectangle spanning the rendered text.
*/
static std::tuple<Mesh, Rectangle> render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage);
/**
* @brief Constructor
* @param font Font
* @param cache Glyph cache
* @param size Font size
*/
explicit TextRenderer(AbstractFont& font, const GlyphCache& cache, Float size);
TextRenderer(AbstractFont&, GlyphCache&&, Float) = delete; /**< @overload */
using AbstractTextRenderer::render;
};
/** @brief Two-dimensional text renderer */
typedef TextRenderer<2> TextRenderer2D;
/** @brief Three-dimensional text renderer */
typedef TextRenderer<3> TextRenderer3D;
}} }}

Loading…
Cancel
Save