ofxVariableLab/src/GPUFontAtlasLayerCombo.cpp

#include "GPUFontAtlasLayerCombo.h"
#include "Utils.h"
#include "font.hpp"
#include "ofColor.h"
#include "ofEvents.h"
#include "ofGraphics.h"
#include "ofRectangle.h"
#include "ofUtils.h"

namespace ofxVariableLab {

void GPUFontAtlasLayerCombo::setup(const ComboIdentifier & identifier,
                                   AtlasLayerComboSettings settings){
    this->identifier = identifier;
    this->settings = static_cast <GPUFontAtlasLayerComboSettings &>(settings);
    #ifdef TARGET_EMSCRIPTEN
        string shaderDir = "data/ofxGPUFont/shaders/DEBUG_ES3";
    #else
        string shaderDir = "data/ofxGPUFont/shaders/GL3";
    #endif
    shaderCatalog = std::make_unique <ofxGPUFont::ShaderCatalog>(shaderDir);
    //backgroundShader = shaderCatalog->get("background");
    fontShader = shaderCatalog->get("font");

    {
        FT_Error error = FT_Init_FreeType(&library);
        if(error){
            std::cerr << "ERROR: failed to initialize FreeType" << std::endl;
            ofExit();
        }
    }
    ofxGPUFont::initializeFont(library,
                               this->identifier.fontPath,
                               font,
                               this->settings.gpuTextureOffset);

    font->listFontVariationAxes(fontVariationAxesParameters, library);
    cout << this->identifier.fontPath << " : fontVariationAxes :" << endl;
    for(const auto & axis : fontVariationAxesParameters){
        cout << std::fixed << std::setprecision(10) << axis.name << " :\n"
             << "\tmin: " << std::to_string(axis.minValue)
             << "\tmax: " << std::to_string(axis.maxValue)
             << "\tdefault: " << std::to_string(axis.defaultValue) << endl;
        fontVariationAxes.push_back({axis.name, axis.defaultValue});
    }

    transform = Transform();

    auto & r = ofGetCurrentRenderer();
    cout << "Render type " << r->getType() << endl;
}
void GPUFontAtlasLayerCombo::update(){
    for(const auto & layer : layers){
        layer->update();
        if(layer->isDirtyDirty()){
            isDirty = true;
            break;
        }
    }
    if(isDirty){
        std::string text = "";
        totalCharacters = 0;
        std::vector <ofxGPUFont::GlyphIdentity> _variationText;
        for(const auto & layer : layers){
            std::string layerText = layer->getProps().text;
            totalCharacters += layerText.length();
            _variationText.insert(_variationText.end(),
                                  layer->getVariationText().begin(),
                                  layer->getVariationText().end());

            text += layerText;
            layer->setDirtyDirty(false); // technically not clean yet
                                         // but this is synchronous
                                         // and will happen, so we can avoid
                                         // another loop
        }
        removeDuplicateCharacters(text);
        mainText = text;
        variationText = std::move(_variationText);
        font->prepareGlyphsForText(variationText,
                                   library,
                                   true);
        isDirty = false;
    }
}
void GPUFontAtlasLayerCombo::careForChild(shared_ptr <Layer> layer){
    if(layer->getType() == LayerType::GPUFONT){
        shared_ptr <GPUFontLayer> gpuFontLayer = static_pointer_cast <GPUFontLayer>(layer);
        gpuFontLayer->setMomsComboIdentifier(identifier);
        gpuFontLayer->isWithNewMom();
        gpuFontLayer->setDirtyDirty(true);
        std::string oldText = mainText;
        std::string layerText = gpuFontLayer->getProps().text;
        std::string text = oldText + layerText;
        totalCharacters += layerText.length();
        removeDuplicateCharacters(text);
        // check if we added any characters
        // TODO: check for variation variations
        if(text.length() != oldText.length()){
            mainText = text;
            isDirty = true;
        }
        layers.push_back(std::move(gpuFontLayer));
    }else{
        ofLogError("GPUFontAtlasLayerCombo::careForChild()") << __LINE__ << ": child is not recognized as Layer::GPUFONT";
    }
}
void GPUFontAtlasLayerCombo::abandonChild(shared_ptr <Layer> layer){
    // TODO: handle removing child text from buffer
    shared_ptr <GPUFontLayer> gpuFontLayer = static_pointer_cast <GPUFontLayer>(layer);
    layers.erase(
        std::remove_if(
            layers.begin(),
            layers.end(),
            [gpuFontLayer](shared_ptr <GPUFontLayer> const & l)
        {
            return l == gpuFontLayer;
        }), layers.end());

    isDirty = true;
    // update the text
    // this doesn't happen very often, so let's just
    // iterate over all layers and calculate fresh
    //std::string text = "";
    //totalCharacters = 0;
    //for(const auto & layer : layers){
    //    std::string layerText = layer->getProps().text;
    //    totalCharacters += layerText.length();
    //    text += layerText;
    //}
    //removeDuplicateCharacters(text);
    //mainText = text;
    // NOTE: we do not want to update buffers now,
    // as it's probably more costly than just keeping
    // the old glyphs around...
}
const ComboIdentifier & GPUFontAtlasLayerCombo::getIdentifier() const {
    return identifier;
}
void GPUFontAtlasLayerCombo::setVFlip(VFlipState vFlipState){
    vFlip = vFlipState;
}
bool GPUFontAtlasLayerCombo::hasChildren(){
    return layers.size() > 0;
}
const vector <shared_ptr <GPUFontLayer> > & GPUFontAtlasLayerCombo::getLayers(){
    return layers;
}
void GPUFontAtlasLayerCombo::draw(){
    GLuint location;

    int width = ofGetWidth();
    int height = ofGetHeight();
    glm::vec2 mouse = glm::vec2(ofGetMouseX(), ofGetMouseY());

    //glm::mat4 projection = transform.getProjectionMatrix((float)width / height);
    glm::mat4 projection = transform.getOrthoProjectionMatrix(width,
                                                              height,
                                                              Transform::TOP_LEFT);
    //Transform::CENTERED);
    glm::mat4 view = transform.getViewMatrix();
    glm::mat4 model = glm::mat4(1.0f);

    //{     // Draw background.
    //GLuint program = backgroundShader->program;
    //glUseProgram(program);
    //glBindVertexArray(emptyVAO);
    //glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    //glBindVertexArray(0);
    //glUseProgram(0);
    //}

    // Uses premultiplied-alpha.
    glEnable(GL_BLEND);
    glBlendEquation(GL_FUNC_ADD);
    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
    ofDisableDepthTest();
    ofEnableAlphaBlending();

    int currentProgram;
    glGetIntegerv(GL_CURRENT_PROGRAM, &currentProgram);

    float superLineHeight = 0;
    if(font){
        fontShaderProgram = fontShader->program;
        glUseProgram(fontShaderProgram);

        font->program = fontShaderProgram;
        font->drawSetup();

        location = glGetUniformLocation(fontShaderProgram, "projection");
        glUniformMatrix4fv(location, 1, false, glm::value_ptr(projection));

        location = glGetUniformLocation(fontShaderProgram, "view");
        glUniformMatrix4fv(location, 1, false, glm::value_ptr(view));
        location = glGetUniformLocation(fontShaderProgram, "model");
        glUniformMatrix4fv(location, 1, false, glm::value_ptr(model));
        float z = 0;
        location = glGetUniformLocation(fontShaderProgram, "z");
        glUniform1f(location, z);


        location = glGetUniformLocation(fontShaderProgram, "antiAliasingWindowSize");
        glUniform1f(location, (float)antiAliasingWindowSize);
        location = glGetUniformLocation(fontShaderProgram, "enableSuperSamplingAntiAliasing");
        glUniform1i(location, enableSuperSamplingAntiAliasing);
        location = glGetUniformLocation(fontShaderProgram, "enableControlPointsVisualization");
        glUniform1i(location, enableControlPointsVisualization);

        std::vector <ofxGPUFont::Font::BufferVertex> vertices;
        std::vector <int32_t> indices;

        vertices.resize(totalCharacters * 4);
        indices.resize(totalCharacters * 6);

        std::vector <ofVboMesh> outerBoundingBoxes;
        for(const auto & layer : layers){
            float lineHeight = font->getLineHeight(layer->getProps().fontSize_px);
            float ascender = font->getAscender(layer->getProps().fontSize_px);
            superLineHeight = lineHeight;
            ofxGPUFont::Font::BoundingBox bb;
            std::vector <ofxGPUFont::Font::BoundingBox> bbs;
            float advanceY = 0;
            font->collectBoundingBoxes(layer->getVariationText(),
                                       bb, bbs, advanceY,
                                       true, layer->getProps().fontSize_px);
            ofNode momNode;
            ofNode node;
            node.setParent(momNode);
            glm::vec4 transformOrigin;
            switch(layer->getProps().transformOrigin){
             default:
             case Layer::TransformOrigin::TOP_LEFT: {
                 node.move(glm::vec3(0,
                                     ascender,
                                     0));
                 momNode.rotateDeg(layer->getProps().rotation, glm::vec3(0, 0, 1));
                 transformOrigin = glm::vec4(layer->getProps().x,
                                             layer->getProps().y - ascender,
                                             0, 1);
                 momNode.move(transformOrigin);
                 break;
             }

             case Layer::TransformOrigin::TOP_RIGHT: {
                 float moveX = bb.p1.x - bb.p0.x;
                 node.move(glm::vec3(-moveX,
                                     ascender,
                                     0));
                 momNode.rotateDeg(layer->getProps().rotation, glm::vec3(0, 0, 1));
                 transformOrigin = glm::vec4(layer->getProps().x + moveX,
                                             layer->getProps().y - ascender,
                                             0, 1);
                 momNode.move(transformOrigin);
                 break;
             }

             case Layer::TransformOrigin::CENTER: {
                 float moveX = (bb.p2.x - bb.p0.x) * 0.5 + bb.p0.x;
                 float moveY = (bb.p2.y - bb.p0.y) * 0.5 - bb.p2.y;
                 node.move(glm::vec3(-moveX,
                                     moveY,
                                     0));
                 momNode.rotateDeg(layer->getProps().rotation, glm::vec3(0, 0, 1));
                 transformOrigin = glm::vec4(layer->getProps().x + moveX,
                                             layer->getProps().y - moveY,
                                             0, 1);
                 momNode.move(transformOrigin);
                 break;
             }

             case Layer::TransformOrigin::BOTTOM_LEFT: {
                 float moveY = ascender - advanceY;
                 node.move(glm::vec3(0,
                                     moveY,
                                     0));
                 momNode.rotateDeg(layer->getProps().rotation, glm::vec3(0, 0, 1));
                 transformOrigin = glm::vec4(layer->getProps().x,
                                             layer->getProps().y - moveY,
                                             0, 1);
                 momNode.move(transformOrigin);
                 break;
             }

             case Layer::TransformOrigin::BOTTOM_RIGHT: {
                 float moveY = ascender - (advanceY);
                 float moveX = (bb.p2.x - bb.p0.x);
                 node.move(glm::vec3(-moveX,
                                     moveY,
                                     0));
                 momNode.rotateDeg(layer->getProps().rotation, glm::vec3(0, 0, 1));
                 transformOrigin = glm::vec4(layer->getProps().x + moveX,
                                             layer->getProps().y - moveY,
                                             0, 1);
                 momNode.move(transformOrigin);
                 break;
             }

            }
            bb.multiply(node.getGlobalTransformMatrix());
            ofVboMesh mesh;
            mesh.addVertices({bb.p0, bb.p1, bb.p2, bb.p3,
                              glm::vec4(layer->getProps().x, layer->getProps().y, 0, 1),
                              transformOrigin
                             });
            mesh.addColors({
                    ofColor::red,
                    ofColor::red,
                    ofColor::red,
                    ofColor::red,
                    ofColor::white,
                    ofColor::green,
                });
            outerBoundingBoxes.push_back(mesh);

            font->collectVerticesAndIndices(node,
                                            bbs,
                                            vertices,
                                            indices,
                                            layer->getColor(),
                                            layer->getProps().fontSize_px);

        }

        font->draw(vertices, indices);

        glUseProgram(currentProgram);
        ofPushStyle();
        ofSetColor(ofColor::white);
        for(const auto & b : outerBoundingBoxes){
            int i = 0;
            for(const auto & v : b.getVertices()){
                ofSetColor(b.getColors()[i]);
                ofDrawCircle(v, 4);
                ofDrawBitmapString(ofToString(i), 0, 0);
                i++;
            }
            b.drawVertices();
        }
        ofFill();
        ofPopStyle();
    }

    glDisable(GL_BLEND);

    ofDrawBitmapStringHighlight(
        "fps: " + ofToString(ofGetFrameRate()) + "\n"
        + "font: " + this->identifier.fontPath + "\n"
        + "lineHEight: " + ofToString(superLineHeight) + "\n"
        , 20, 20);
}

}