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.

src/Text/Test/GlyphCacheGLTest.cpp

@@ -46,7 +46,9 @@ void GlyphCacheGLTest::initialize() {
     Text::GlyphCache cache({1024, 2048});
     MAGNUM_VERIFY_NO_ERROR();
 
+    #ifndef MAGNUM_TARGET_GLES
     CORRADE_COMPARE(cache.texture()->imageSize(0), Vector2i(1024, 2048));
+    #endif
 }
 
 void GlyphCacheGLTest::access() {

src/Text/Test/TextRendererGLTest.cpp

@@ -168,6 +168,8 @@ void TextRendererGLTest::renderMesh() {
     std::tie(mesh, bounds) = Text::TextRenderer3D::render(&font, nullptr, 0.25f, "abc", &vertexBuffer, &indexBuffer, Buffer::Usage::StaticDraw);
     MAGNUM_VERIFY_NO_ERROR();
 
+    /** @todo How to verify this on ES? */
+    #ifndef MAGNUM_TARGET_GLES
     /* Vertex buffer contents */
     Containers::Array<Float> vertices = vertexBuffer.data<Float>();
     CORRADE_COMPARE(std::vector<Float>(vertices.begin(), vertices.end()), (std::vector<Float>{
@@ -193,6 +195,7 @@ void TextRendererGLTest::renderMesh() {
         4,  5,  6,  5,  7,  6,
         8,  9, 10,  9, 11, 10
     }));
+    #endif
 
     /* Bounds */
     CORRADE_COMPARE(bounds, Rectangle({0.0f, -0.5f}, {5.0f, 1.0f}));
@@ -209,6 +212,8 @@ void TextRendererGLTest::mutableText() {
     renderer.reserve(4, Buffer::Usage::StaticDraw, Buffer::Usage::StaticDraw);
     MAGNUM_VERIFY_NO_ERROR();
     CORRADE_COMPARE(renderer.capacity(), 4);
+    /** @todo How to verify this on ES? */
+    #ifndef MAGNUM_TARGET_GLES
     Containers::Array<UnsignedByte> indices = renderer.indexBuffer()->data<UnsignedByte>();
     CORRADE_COMPARE(std::vector<UnsignedByte>(indices.begin(), indices.end()), (std::vector<UnsignedByte>{
          0,  1,  2,  1,  3,  2,
@@ -216,10 +221,13 @@ void TextRendererGLTest::mutableText() {
          8,  9, 10,  9, 11, 10,
         12, 13, 14, 13, 15, 14
     }));
+    #endif
 
     /* Render text */
     renderer.render("abc");
     MAGNUM_VERIFY_NO_ERROR();
+    /** @todo How to verify this on ES? */
+    #ifndef MAGNUM_TARGET_GLES
     Containers::Array<Float> vertices = renderer.vertexBuffer()->subData<Float>(0, 48);
     CORRADE_COMPARE(std::vector<Float>(vertices.begin(), vertices.end()), (std::vector<Float>{
         0.0f,  0.5f, 0.0f, 10.0f,
@@ -237,6 +245,7 @@ void TextRendererGLTest::mutableText() {
         5.0f,   1.0f, 18.0f, 10.0f,
         5.0f,  -0.5f, 18.0f,  0.0f
     }));
+    #endif
 
     /* Updated bounds */
     CORRADE_COMPARE(renderer.rectangle(), Rectangle({0.0f, -0.5f}, {5.0f, 1.0f}));

src/Text/TextRenderer.cpp

@@ -208,10 +208,13 @@ template<UnsignedInt dimensions> std::tuple<Mesh, Rectangle> TextRenderer<dimens
 AbstractTextRenderer::AbstractTextRenderer(AbstractFont* const font, const GlyphCache* const cache, Float size): _vertexBuffer(Buffer::Target::Array), _indexBuffer(Buffer::Target::ElementArray), font(font), cache(cache), size(size), _capacity(0) {
     #ifndef MAGNUM_TARGET_GLES
     MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::ARB::map_buffer_range);
-    #else
-    #ifdef MAGNUM_TARGET_GLES2
-    MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::EXT::map_buffer_range);
-    #endif
+    #elif defined(MAGNUM_TARGET_GLES2)
+    if(!Context::current()->isExtensionSupported<Extensions::GL::EXT::map_buffer_range>()) {
+        MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::OES::mapbuffer);
+        Warning() << "Text::TextRenderer:" << Extensions::GL::EXT::map_buffer_range::string()
+                  << "is not supported, using less efficient" << Extensions::GL::OES::mapbuffer::string()
+                  << "instead";
+    }
     #endif
 
     /* Vertex buffer configuration depends on dimension count, done in subclass */
@@ -254,8 +257,18 @@ void AbstractTextRenderer::reserve(const uint32_t glyphCount, const Buffer::Usag
     _mesh.setIndexCount(0)
         ->setIndexBuffer(&_indexBuffer, 0, indexType, 0, vertexCount);
 
+    /* Map buffer for filling */
+    void* indices;
+    #ifdef MAGNUM_TARGET_GLES2
+    if(Context::current()->isExtensionSupported<Extensions::GL::EXT::map_buffer_range>())
+    #endif
+        CORRADE_INTERNAL_ASSERT_OUTPUT(indices = _indexBuffer.map(0, indicesSize,
+            Buffer::MapFlag::InvalidateBuffer|Buffer::MapFlag::Write));
+    #ifdef MAGNUM_TARGET_GLES2
+    else CORRADE_INTERNAL_ASSERT_OUTPUT(indices = _indexBuffer.map(Buffer::MapAccess::WriteOnly));
+    #endif
+
     /* Prefill index buffer */
-    void* indices = _indexBuffer.map(0, indicesSize, Buffer::MapFlag::InvalidateBuffer|Buffer::MapFlag::Write);
     if(vertexCount < 255)
         createIndices<UnsignedByte>(indices, glyphCount);
     else if(vertexCount < 65535)
@@ -274,9 +287,20 @@ void AbstractTextRenderer::render(const std::string& text) {
     /* Reset rendered rectangle */
     _rectangle = {};
 
+    /* Map buffer for rendering */
+    Vertex* vertices;
+    #ifdef MAGNUM_TARGET_GLES2
+    if(Context::current()->isExtensionSupported<Extensions::GL::EXT::map_buffer_range>())
+    #endif
+        CORRADE_INTERNAL_ASSERT_OUTPUT(vertices = static_cast<Vertex*>(_vertexBuffer.map(0,
+            layouter->glyphCount()*4*sizeof(Vertex),
+            Buffer::MapFlag::InvalidateBuffer|Buffer::MapFlag::Write)));
+    #ifdef MAGNUM_TARGET_GLES2
+    else CORRADE_INTERNAL_ASSERT_OUTPUT(vertices =
+        static_cast<Vertex*>(_vertexBuffer.map(Buffer::MapAccess::WriteOnly)));
+    #endif
+
     /* Render all glyphs */
-    Vertex* const vertices = static_cast<Vertex*>(_vertexBuffer.map(0, layouter->glyphCount()*4*sizeof(Vertex),
-        Buffer::MapFlag::InvalidateBuffer|Buffer::MapFlag::Write));
     Vector2 cursorPosition;
     for(UnsignedInt i = 0; i != layouter->glyphCount(); ++i) {
         /* Position of the texture in the resulting glyph, texture coordinates */

src/Text/TextRenderer.h

@@ -197,9 +197,10 @@ renderer.mesh().draw();
 
 @section TextRenderer-extensions Required OpenGL functionality
 
-Mutable text rendering requires @extension{ARB,map_buffer_range} (also part of
-OpenGL ES 3.0 or available as @es_extension{EXT,map_buffer_range} in ES 2.0)
-for asynchronous buffer updates.
+Mutable text rendering requires @extension{ARB,map_buffer_range} on desktop
+OpenGL (also part of OpenGL ES 3.0). If @es_extension{EXT,map_buffer_range} is
+not available in ES 2.0, at least @es_extension{OES,mapbuffer} must be
+supported for asynchronous buffer updates.
 
 @see TextRenderer2D, TextRenderer3D, Font, Shaders::AbstractVectorShader
 */