The original code assumed that the text bounds lower left corner is
always at origin. It is now not the case with multi-line text. All tests
now pass again.
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.
The virtual method is moved to doRenderGlyph(), for plugin implementers
it means that the function only needs to be renamed (and moved to private
section) and plugin version interface needs to be updated.
The common layouting code allows to remove many redundant code from
Renderer and also ability to test cursor position/bounding rectangle
updated properly. Rectangle updating now treats rectangle with zero size
as invalid and replaces it with glyph quad instead of merging the two. It
means that the returned rectangle now wraps the text more tightly and
does not always contain origin.
Got finally pissed with the requirement of setting AbstractFont::_size
manually and took this as opportunity to rework the internal plugin API
in a better way. Bumped the interface version, as this is binary
incompatible. MagnumFont doesn't support lineHeight yet.
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.
Operators that are part of Vector are operating only with the same type
as Vector itself, operators for multiplying/dividing integral vectors
with floating-point numbers and vectors are now out-of-class and enabled
only for integer vectors. It allows better control (e.g. multiplying
integer and floating-point vector will _always_ result in floating-point
one). Thoroughly tested integer/FP operations and also reworked and
tested operator and funciton reimplementations in subclasses, both for
value correctness and result type correctness.
In 1.8.5 it is now possible to reference directly to enum member.
Hooray! Also added explicit @ref here and there, fixing some referencing
bugs along the way.
MinGW (or Windows at general?!) somehow doesn't expect four-byte
characters in a string and this class fails miserably when freeing
memory. Replaced with std::vector<char32_t>, it's horrendously ugly
solution, but I hope this will be resolved soon with newer MinGW GCC
(4.7.2 fails).
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.
Makes some cases less consistent (and some convenience shortcuts
impossible), but goes well with the attitude "don't use pointer when it
can't be null".
The parameter unnecessarily complicates the implementation, as it needs
to be reimplemented in _every_ plugin (and all current plugins have bug
in it).