ofxVariableLab/src/GPUFontAtlasLayerCombo.cpp

#include "GPUFontAtlasLayerCombo.h"
#include "Utils.h"
#include "ofColor.h"
#include "ofEvents.h"
#include "ofGraphics.h"
#include "ofUtils.h"

namespace ofxVariableLab {

void GPUFontAtlasLayerCombo::setup(const ComboIdentifier & identifier){
    this->identifier = identifier;
    #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();
        }
    }
    currentFontPath = "data/celines-fonts/Version-2-var.ttf";
    mainText = "whatever";
    ofxGPUFont::tryUpdateMainFont(library,
                                  currentFontPath,
                                  mainText,
                                  font,
                                  bb);

    font->listFontVariationAxes(fontVariationAxesParameters, library);
    cout << currentFontPath << " : 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(){
    //#ifndef TARGET_OPENGLES
    //if(ofGetFrameNum() % 10 == 0){
    //shaderCatalog->requestUpdate("font");
    //}else if(ofGetFrameNum() % 10 == 5){
    //shaderCatalog->update();
    //}
    //#endif
    float animationSpeed = 1.0;
    float threshold = 1.0;
    for(int i = 0; i < fontVariationAxes.size(); i++){
        ofxGPUFont::Font::FontVariationAxis & axis = fontVariationAxes[i];
        ofxGPUFont::Font::FontVariationAxisParameters & axisParams = fontVariationAxesParameters[i];
        double newValue = ofMap(sin(ofGetElapsedTimef() * animationSpeed),
                                -1, 1,
                                axisParams.minValue, axisParams.maxValue);
        if(abs(newValue - axis.value) > threshold){
            font->setFontVariationAxis(library, axis.name, newValue);
            axis.value = newValue;
            font->prepareGlyphsForText(mainText, true);
        }
    }
}
void GPUFontAtlasLayerCombo::careForChild(shared_ptr <Layer> layer){
}
const ComboIdentifier & GPUFontAtlasLayerCombo::getIdentifier() const {
    return identifier;
}
void GPUFontAtlasLayerCombo::setVFlip(VFlipState vFlipState){
    vFlip = vFlipState;
}
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());

    float targetFontSize = 128;

    float width_unit = 1;
    float height_unit = (float)height / width;

    //ofClear(125, 255, 125, 255);

    //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 cx = FLT_MAX;
    float cy = FLT_MAX;
    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, "color");
        glUniform4f(location, 1.0f, 1.0f, 1.0f, 0.5f);

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


        //mouse.x = 0;
        //mouse.y = 0;
        std::vector <ofxGPUFont::Font::BufferVertex> vertices;
        std::vector <int32_t> indices;
        string text = "whatever";
        int n_texts = 240;
        vertices.resize(text.length() * n_texts * 4);
        indices.resize(text.length() * n_texts * 6);
        cx = 0.5f * (bb.minX + bb.maxX);
        cy = 0.5f * (bb.minY + bb.maxY);

        for(int i = 0; i < n_texts - 1; i++){
            float pipi = ((PI * 2 * i) / (n_texts - 1));
            float shift = (400 * cos(ofGetElapsedTimef() * 0.125 + pipi));
            float shift_x = (600 * sin(ofGetElapsedTimef() * 0.125 + pipi));
            float shift_o = (100 * sin(ofGetElapsedTimef() * 0.4 + pipi));
            font->collectVerticesAndIndices(
                glm::vec3(mouse.x + shift_x,
                          mouse.y + shift + shift_o,
                          0),
                text,
                vertices,
                indices,
                true,
                int(ofMap(sin(ofGetElapsedTimef() + pipi), -1, 1, 42, 96)));
        }
        font->collectVerticesAndIndices(
            glm::vec3(mouse.x,
                      mouse.y,
                      0),
            text,
            vertices,
            indices,
            true,
            ofMap(sin(ofGetElapsedTimef() * 0.25f), -1.0f, 1.0f, 42.0f, 96.0f));
        font->draw(vertices, indices);
        //ofRectangle rectangle(0, 0, width, height);
        //ofDrawRectangle(rectangle);
        //font->draw(mouse.x, mouse.y - (200 * sin(ofGetElapsedTimef() * 0.25)), 0, "what", vFlip == V_FLIP_ON, 42.0f);
        //location = glGetUniformLocation(fontShaderProgram, "color");
        //glUniform4f(location, 0.0f, 1.0f, 0.0f, 0.5f);
        //font->draw(mouse.x, mouse.y, 0, "ever", vFlip == V_FLIP_ON, 420.0f);

        glUseProgram(currentProgram);
    }

    glDisable(GL_BLEND);

    //ofDrawBitmapStringHighlight(
    //(ofToString("and we know:") + ofToString("everything"))
    //, 100 + mouse.x, mouse.y, ofFloatColor::pink, ofFloatColor::black);

    ofDrawBitmapStringHighlight(
        "fps: " + ofToString(ofGetFrameRate()) + "\n"
        + "font: " + currentFontPath + "\n"
        + "cx: " + ofToString(cx) + "\n"
        + "cy: " + ofToString(cy) + "\n"
        , 20, 20);
}

}