ofxVariableLab/src/LayerComposition.cpp

#include "LayerComposition.h"
#include "Atlas.h"
#include "MsdfLayer.h"
#include "Utils.h"
#include "ofUtils.h"
#include <memory>

namespace ofxVariableLab {

void MsdfAtlasLayerCombo::setup(const ComboIdentifier & layerIdentifier){
    this->identifier = layerIdentifier;
    ofxMsdfgen::AtlasSettings atlasSettings;
    //settings.characters = "ABCDEFGHIJKL";
    atlasSettings.scale = 64;
    atlasSettings.minimumScale = 64;
    atlasSettings.characters = "";
    atlasSettings.maxInterpolationStepSize = 50.0;

    atlas = make_shared <ofxMsdfgen::Atlas>();

    msdfShader = make_shared <ofShader>();
    #ifdef TARGET_EMSCRIPTEN
        msdfShader->load("ofxMsdfgen/shaders/mix/ES3/shader");
    #else
        msdfShader->load("ofxMsdfgen/shaders/mix/GL3/shader");
    #endif

    atlas->setup(this->identifier.fontPath, atlasSettings);
}

void MsdfAtlasLayerCombo::update(){
    if(isDirty){
        atlas->generate();
        isDirty = false;
    }
}

void MsdfAtlasLayerCombo::careForChild(shared_ptr <Layer> layer){
    shared_ptr <MsdfLayer> msdfLayer = dynamic_pointer_cast <MsdfLayer>(layer);
    msdfLayer->setAtlas(this->atlas);
    msdfLayer->setShader(msdfShader);
    auto & as = atlas->settings;
    for(const char c : layer->getProps().text){
        if(as.characters.find(c) == std::string::npos){
            // not found
            as.characters += c;
            isDirty = true;
        }
    }
    layers.push_back(msdfLayer);
}

const ComboIdentifier & MsdfAtlasLayerCombo::getIdentifier() const {
    return identifier;
}

const ofImage & MsdfAtlasLayerCombo::getAtlasImage(){
    return atlas->getAtlasImage();
}

string MsdfAtlasLayerCombo::getAtlasImagePath(){
    return atlas->getAtlasPath();
}

void LayerComposition::setup(){
}

void LayerComposition::update(){
    for(const auto & atlasLayerCombo : atlasLayerCombos){
        atlasLayerCombo.second->update();
    }
}

LayerID LayerComposition::addLayer(const ComboIdentifier & identifier,
                                   const string & text,
                                   const std::vector <FontVariation> & variations){
    auto props = Layer::Props();
    props.text = text;
    props.fontPath = identifier.fontPath;
    return addLayer(identifier,
                    props,
                    variations);
}

LayerID LayerComposition::addLayer(const ComboIdentifier & identifier,
                                   const Layer::Props & props,
                                   const std::vector <FontVariation> & variations){
    string layerID = "";
    if(atlasLayerCombos.count(identifier) <= 0){
        switch(identifier.type){
         case Layer::GPUFONT: {
             ofLogError("LayerComposition::addLayer")
                 << "GPUFont not implemented" << endl;
             break;
         }

         default:
         case Layer::MSDFGEN: {
             // TODO: put most stuff in combo setup
             auto combo = make_shared <MsdfAtlasLayerCombo>();
             combo->setup(identifier); // TODO: add here text and variations
             auto layer = make_shared <MsdfLayer>();
             layer->setProps(props);
             layer->setup();
             std::vector <ofxMsdfgen::FontVariation> msdfVariations;
             for(const auto & v : variations){
                 msdfVariations.push_back({v.name, v.value});
             }
             // TODO: do not add Variation to atlas, but to combo,
             // so we know it's dirty
             combo->atlas->addVariations(msdfVariations);
             combo->careForChild(layer);
             layers[layer->getId()] = layer;
             atlasLayerCombos[identifier] = std::move(combo);
             layerID = layer->getId();
         }
        }
    }
    return layerID;
}

shared_ptr <Layer> LayerComposition::getLayer(const LayerID & layerID){
    return layers[layerID];
}

const ofImage & LayerComposition::getAtlasImage(const ComboIdentifier & identifier){
    return atlasLayerCombos[identifier]->getAtlasImage();
}

void LayerComposition::draw() const {
    for(const auto & layer_it : layers){
        layer_it.second->draw();
    }
}

const std::vector <ComboIdentifier> LayerComposition::getAvailableComboIdentifiers() const {
    std::vector <ComboIdentifier> combos;
    for(const auto & combo : atlasLayerCombos){
        combos.push_back(combo.first);
    }
    return combos;
}

const unordered_map <ComboIdentifier, shared_ptr <AtlasLayerCombo> > & LayerComposition::getAtlasLayerCombos() const {
    return atlasLayerCombos;
}

}