////  TextRenderer.cpp//  interface/src/ui////  Created by Andrzej Kapolka on 4/24/13.//  Copyright 2013 High Fidelity, Inc.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html// #include <QApplication>#include <QDesktopWidget>#include <QFont>#include <QPaintEngine>#include <QtDebug>#include <QString>#include <QStringList>#include <QWindow> #include "InterfaceConfig.h"#include "TextRenderer.h" #include "glm/glm.hpp"#include <glm/gtc/matrix_transform.hpp> #include "gpu/GLBackend.h"#include "gpu/Stream.h"  // the width/height of the cached glyph texturesconst int IMAGE_SIZE = 512; static uint qHash(const TextRenderer::Properties& key, uint seed = 0) {    // can be switched to qHash(key.font, seed) when we require Qt 5.3+    return qHash(key.font.family(), qHash(key.font.pointSize(), seed));} static bool operator==(const TextRenderer::Properties& p1, const TextRenderer::Properties& p2) {    return p1.font == p2.font && p1.effect == p2.effect && p1.effectThickness == p2.effectThickness && p1.color == p2.color;} TextRenderer* TextRenderer::getInstance(const char* family, int pointSize, int weight, bool italic,        EffectType effect, int effectThickness, const QColor& color) {    Properties properties = { QFont(family, pointSize, weight, italic), effect, effectThickness, color };    TextRenderer*& instance = _instances[properties];    if (!instance) {        instance = new TextRenderer(properties);    }    return instance;} TextRenderer::~TextRenderer() {    glDeleteTextures(_allTextureIDs.size(), _allTextureIDs.constData());} int TextRenderer::calculateHeight(const char* str) {    int maxHeight = 0;    for (const char* ch = str; *ch != 0; ch++) {        const Glyph& glyph = getGlyph(*ch);        if (glyph.textureID() == 0) {            continue;        }                if (glyph.bounds().height() > maxHeight) {            maxHeight = glyph.bounds().height();        }    }    return maxHeight;} int TextRenderer::draw(int x, int y, const char* str, float alpha) {    // Grab the current color    float currentColor[4];    glGetFloatv(GL_CURRENT_COLOR, currentColor);    alpha = std::max(0.0f, std::min(alpha, 1.0f));    currentColor[3] *= alpha;    int compactColor = ((int(currentColor[0] * 255.0f) & 0xFF)) |                       ((int(currentColor[1] * 255.0f) & 0xFF) << 8) |                       ((int(currentColor[2] * 255.0f) & 0xFF) << 16) |                       ((int(currentColor[3] * 255.0f) & 0xFF) << 24); // TODO: Remove that code once we test for performance improvments    //glEnable(GL_TEXTURE_2D);     int maxHeight = 0;    for (const char* ch = str; *ch != 0; ch++) {        const Glyph& glyph = getGlyph(*ch);        if (glyph.textureID() == 0) {            x += glyph.width();            continue;        }                if (glyph.bounds().height() > maxHeight) {            maxHeight = glyph.bounds().height();        }        //glBindTexture(GL_TEXTURE_2D, glyph.textureID());         int left = x + glyph.bounds().x();        int right = x + glyph.bounds().x() + glyph.bounds().width();        int bottom = y + glyph.bounds().y();        int top = y + glyph.bounds().y() + glyph.bounds().height();         glm::vec2  leftBottom = glm::vec2(float(left), float(bottom));        glm::vec2  rightTop = glm::vec2(float(right), float(top));         float scale = QApplication::desktop()->windowHandle()->devicePixelRatio() / IMAGE_SIZE;        float ls = glyph.location().x() * scale;        float rs = (glyph.location().x() + glyph.bounds().width()) * scale;        float bt = glyph.location().y() * scale;        float tt = (glyph.location().y() + glyph.bounds().height()) * scale; // TODO: Remove that code once we test for performance improvments/*        glBegin(GL_QUADS);        glTexCoord2f(ls, bt);        glVertex2f(left, bottom);        glTexCoord2f(rs, bt);        glVertex2f(right, bottom);        glTexCoord2f(rs, tt);        glVertex2f(right, top);        glTexCoord2f(ls, tt);        glVertex2f(left, top);        glEnd();*/         const int NUM_COORDS_SCALARS_PER_GLYPH = 16;        float vertexBuffer[NUM_COORDS_SCALARS_PER_GLYPH] = {    leftBottom.x, leftBottom.y, ls, bt,                                                        rightTop.x, leftBottom.y, rs, bt,                                                        rightTop.x, rightTop.y, rs, tt,                                                        leftBottom.x, rightTop.y, ls, tt, };         const int NUM_COLOR_SCALARS_PER_GLYPH = 4;        int colorBuffer[NUM_COLOR_SCALARS_PER_GLYPH] = { compactColor, compactColor, compactColor, compactColor };         gpu::Buffer::Size offset = sizeof(vertexBuffer) * _numGlyphsBatched;        gpu::Buffer::Size colorOffset = sizeof(colorBuffer) * _numGlyphsBatched;        if ((offset + sizeof(vertexBuffer)) > _glyphsBuffer->getSize()) {            _glyphsBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);            _glyphsColorBuffer->append(sizeof(colorBuffer), (gpu::Buffer::Byte*) colorBuffer);        } else {            _glyphsBuffer->setSubData(offset, sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);            _glyphsColorBuffer->setSubData(colorOffset, sizeof(colorBuffer), (gpu::Buffer::Byte*) colorBuffer);        }        _numGlyphsBatched++;         x += glyph.width();    }     // TODO: remove these calls once we move to a full batched rendering of the text, for now, one draw call per draw() function call    drawBatch();    clearBatch(); // TODO: Remove that code once we test for performance improvments   // glBindTexture(GL_TEXTURE_2D, 0);   // glDisable(GL_TEXTURE_2D);     return maxHeight;} int TextRenderer::computeWidth(char ch){    return getGlyph(ch).width();} int TextRenderer::computeWidth(const char* str){    int width = 0;    for (const char* ch = str; *ch != 0; ch++) {        width += computeWidth(*ch);    }    return width;} TextRenderer::TextRenderer(const Properties& properties) :    _font(properties.font),    _metrics(_font),    _effectType(properties.effect),    _effectThickness(properties.effectThickness),    _x(IMAGE_SIZE),    _y(IMAGE_SIZE),    _rowHeight(0),    _color(properties.color),    _glyphsBuffer(new gpu::Buffer()),    _glyphsColorBuffer(new gpu::Buffer()),    _glyphsStreamFormat(new gpu::Stream::Format()),    _glyphsStream(new gpu::BufferStream()),    _numGlyphsBatched(0){    _glyphsStreamFormat->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::POS_XYZ), 0);    const int NUM_POS_COORDS = 2;    const int VERTEX_TEXCOORD_OFFSET = NUM_POS_COORDS * sizeof(float);    _glyphsStreamFormat->setAttribute(gpu::Stream::TEXCOORD, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::UV), VERTEX_TEXCOORD_OFFSET);     _glyphsStreamFormat->setAttribute(gpu::Stream::COLOR, 1, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));     _glyphsStream->addBuffer(_glyphsBuffer, 0, _glyphsStreamFormat->getChannels().at(0)._stride);    _glyphsStream->addBuffer(_glyphsColorBuffer, 0, _glyphsStreamFormat->getChannels().at(1)._stride);     _font.setKerning(false);} const Glyph& TextRenderer::getGlyph(char c) {    Glyph& glyph = _glyphs[c];    if (glyph.isValid()) {        return glyph;    }    // we use 'J' as a representative size for the solid block character    QChar ch = (c == SOLID_BLOCK_CHAR) ? QChar('J') : QChar(c);    QRect baseBounds = _metrics.boundingRect(ch);    if (baseBounds.isEmpty()) {        glyph = Glyph(0, QPoint(), QRect(), _metrics.width(ch));        return glyph;    }    // grow the bounds to account for effect, if any    if (_effectType == SHADOW_EFFECT) {        baseBounds.adjust(-_effectThickness, 0, 0, _effectThickness);        } else if (_effectType == OUTLINE_EFFECT) {        baseBounds.adjust(-_effectThickness, -_effectThickness, _effectThickness, _effectThickness);    }        // grow the bounds to account for antialiasing    baseBounds.adjust(-1, -1, 1, 1);        // adjust bounds for device pixel scaling    float ratio = QApplication::desktop()->windowHandle()->devicePixelRatio();    QRect bounds(baseBounds.x() * ratio, baseBounds.y() * ratio, baseBounds.width() * ratio, baseBounds.height() * ratio);        if (_x + bounds.width() > IMAGE_SIZE) {        // we can't fit it on the current row; move to next        _y += _rowHeight;        _x = _rowHeight = 0;    }    if (_y + bounds.height() > IMAGE_SIZE) {        // can't fit it on current texture; make a new one        glGenTextures(1, &_currentTextureID);        _x = _y = _rowHeight = 0;                glBindTexture(GL_TEXTURE_2D, _currentTextureID);        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, IMAGE_SIZE, IMAGE_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);        _allTextureIDs.append(_currentTextureID);               } else {        glBindTexture(GL_TEXTURE_2D, _currentTextureID);    }    // render the glyph into an image and copy it into the texture    QImage image(bounds.width(), bounds.height(), QImage::Format_ARGB32);    if (c == SOLID_BLOCK_CHAR) {        image.fill(_color);        } else {        image.fill(0);        QPainter painter(&image);        QFont font = _font;        if (ratio == 1.0f) {            painter.setFont(_font);        } else {            QFont enlargedFont = _font;            enlargedFont.setPointSize(_font.pointSize() * ratio);            painter.setFont(enlargedFont);        }        if (_effectType == SHADOW_EFFECT) {            for (int i = 0; i < _effectThickness * ratio; i++) {                painter.drawText(-bounds.x() - 1 - i, -bounds.y() + 1 + i, ch);            }        } else if (_effectType == OUTLINE_EFFECT) {            QPainterPath path;            QFont font = _font;            font.setStyleStrategy(QFont::ForceOutline);            path.addText(-bounds.x() - 0.5, -bounds.y() + 0.5, font, ch);            QPen pen;            pen.setWidth(_effectThickness * ratio);            pen.setJoinStyle(Qt::RoundJoin);            pen.setCapStyle(Qt::RoundCap);            painter.setPen(pen);            painter.setRenderHint(QPainter::Antialiasing);            painter.drawPath(path);        }        painter.setPen(_color);        painter.drawText(-bounds.x(), -bounds.y(), ch);    }        glTexSubImage2D(GL_TEXTURE_2D, 0, _x, _y, bounds.width(), bounds.height(), GL_RGBA, GL_UNSIGNED_BYTE, image.constBits());           glyph = Glyph(_currentTextureID, QPoint(_x / ratio, _y / ratio), baseBounds, _metrics.width(ch));    _x += bounds.width();    _rowHeight = qMax(_rowHeight, bounds.height());        glBindTexture(GL_TEXTURE_2D, 0);    return glyph;} void TextRenderer::drawBatch() {    if (_numGlyphsBatched <= 0) {        return;    }     // TODO: Right now the drawBatch is called while calling the draw() function but in the future we'll need to apply the correct transform stack    /*    GLint matrixMode;    glGetIntegerv(GL_MATRIX_MODE, &matrixMode);     glMatrixMode(GL_MODELVIEW);    glPushMatrix();    glLoadIdentity();     glMatrixMode(GL_PROJECTION);    glPushMatrix();    glLoadIdentity();    */     gpu::Batch batch;     glEnable(GL_TEXTURE_2D);    // TODO: Apply the correct font atlas texture, for now only one texture per TextRenderer so it should be good    glBindTexture(GL_TEXTURE_2D, _currentTextureID);     batch.setInputFormat(_glyphsStreamFormat);    batch.setInputStream(0, *_glyphsStream);    batch.draw(gpu::QUADS, _numGlyphsBatched * 4, 0);     gpu::GLBackend::renderBatch(batch);     glDisableClientState(GL_VERTEX_ARRAY);    glDisableClientState(GL_TEXTURE_COORD_ARRAY);    glDisableClientState(GL_COLOR_ARRAY);     glBindBuffer(GL_ARRAY_BUFFER, 0);     glBindTexture(GL_TEXTURE_2D, 0);    glDisable(GL_TEXTURE_2D);     // TODO: Right now the drawBatch is called while calling the draw() function but in the future we'll need to apply the correct transform stack    /*    glPopMatrix();    glMatrixMode(GL_MODELVIEW);    glPopMatrix();    glMatrixMode(matrixMode);    */} void TextRenderer::clearBatch() {    _numGlyphsBatched = 0;} QHash<TextRenderer::Properties, TextRenderer*> TextRenderer::_instances; Glyph::Glyph(int textureID, const QPoint& location, const QRect& bounds, int width) :    _textureID(textureID), _location(location), _bounds(bounds), _width(width) {}