2023-03-25 18:59:58 +01:00
|
|
|
#include "LayerComposition.h"
|
2023-04-06 11:17:22 +02:00
|
|
|
#include "Atlas.h"
|
2023-04-13 17:15:35 +02:00
|
|
|
#include "GPUFontAtlasLayerCombo.h"
|
2023-04-06 11:17:22 +02:00
|
|
|
#include "MsdfLayer.h"
|
2023-04-07 09:48:37 +02:00
|
|
|
#include "Utils.h"
|
2023-03-26 19:42:57 +02:00
|
|
|
#include "ofUtils.h"
|
2023-03-26 21:19:37 +02:00
|
|
|
#include <memory>
|
2023-03-25 18:59:58 +01:00
|
|
|
|
|
|
|
namespace ofxVariableLab {
|
|
|
|
|
2023-04-06 11:17:22 +02:00
|
|
|
void LayerComposition::setup(){
|
2023-04-13 17:15:35 +02:00
|
|
|
//auto combo = make_shared <GPUFontAtlasLayerCombo>();
|
|
|
|
//ComboIdentifier comboIdentifier = {"lol", Layer::GPUFONT};
|
|
|
|
//combo->setup(comboIdentifier);
|
|
|
|
//atlasLayerCombos[comboIdentifier] = combo;
|
2023-03-25 18:59:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void LayerComposition::update(){
|
2023-04-06 11:17:22 +02:00
|
|
|
for(const auto & atlasLayerCombo : atlasLayerCombos){
|
|
|
|
atlasLayerCombo.second->update();
|
|
|
|
}
|
2023-03-25 18:59:58 +01:00
|
|
|
}
|
2023-04-14 16:55:15 +02:00
|
|
|
LayerID LayerComposition::addLayer(const Layer::Props & props,
|
|
|
|
LayerID layerID){
|
|
|
|
ComboIdentifier identifier;
|
|
|
|
identifier.fontPath = props.fontPath;
|
|
|
|
identifier.type = Layer::GPUFONT;
|
|
|
|
string text = props.text;
|
|
|
|
std::vector <FontVariation> variations = {
|
|
|
|
{"Weight", 100.0},
|
|
|
|
{"Weight", 700.0}
|
|
|
|
};
|
|
|
|
return addLayer(identifier,
|
|
|
|
text,
|
|
|
|
variations,
|
|
|
|
layerID);
|
|
|
|
|
|
|
|
}
|
2023-03-25 18:59:58 +01:00
|
|
|
|
2023-04-07 16:17:07 +02:00
|
|
|
LayerID LayerComposition::addLayer(const ComboIdentifier & identifier,
|
|
|
|
const string & text,
|
2023-04-14 16:55:15 +02:00
|
|
|
const std::vector <FontVariation> & variations,
|
|
|
|
LayerID layerID){
|
2023-04-11 12:23:14 +02:00
|
|
|
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,
|
2023-04-14 16:55:15 +02:00
|
|
|
const std::vector <FontVariation> & variations,
|
|
|
|
LayerID layerID){
|
2023-04-13 17:15:35 +02:00
|
|
|
switch(identifier.type){
|
|
|
|
case Layer::GPUFONT: {
|
|
|
|
shared_ptr <GPUFontAtlasLayerCombo> combo;
|
|
|
|
auto comboIterator = atlasLayerCombos.find(identifier);
|
|
|
|
if(comboIterator == atlasLayerCombos.end()){
|
|
|
|
// we don't have one yet
|
|
|
|
// so let's create it
|
|
|
|
combo = make_shared <GPUFontAtlasLayerCombo>();
|
|
|
|
GPUFontAtlasLayerComboSettings settings;
|
|
|
|
settings.gpuTextureOffset = nextGpuTextureOffset;
|
|
|
|
combo->setup(identifier, settings);
|
|
|
|
nextGpuTextureOffset++;
|
|
|
|
atlasLayerCombos[identifier] = combo;
|
|
|
|
}else{
|
|
|
|
// use existing combo
|
|
|
|
combo = dynamic_pointer_cast <GPUFontAtlasLayerCombo>(comboIterator->second);
|
2023-04-06 11:17:22 +02:00
|
|
|
}
|
|
|
|
|
2023-04-13 17:15:35 +02:00
|
|
|
auto layer = make_shared <GPUFontLayer>();
|
2023-04-14 16:55:15 +02:00
|
|
|
layer->vFlip = vFlipState;
|
2023-04-13 17:15:35 +02:00
|
|
|
layer->setProps(props);
|
2023-04-14 16:55:15 +02:00
|
|
|
layer->setup();
|
|
|
|
if(layerID == ""){
|
|
|
|
layerID = layer->getId();
|
|
|
|
cout << "yess layerID is now " << layerID << "!" << endl;
|
|
|
|
}else{
|
|
|
|
layer->setId(layerID);
|
|
|
|
}
|
2023-04-13 17:15:35 +02:00
|
|
|
combo->careForChild(layer);
|
|
|
|
layers[layerID] = layer;
|
|
|
|
|
|
|
|
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->vFlip = vFlipState;
|
|
|
|
layer->setProps(props);
|
|
|
|
layer->setup();
|
2023-04-14 16:55:15 +02:00
|
|
|
if(layerID == ""){
|
|
|
|
layerID = layer->getId();
|
|
|
|
}else{
|
|
|
|
layer->setId(layerID);
|
|
|
|
}
|
2023-04-13 17:15:35 +02:00
|
|
|
std::vector <ofxMsdfgen::FontVariation> msdfVariations;
|
|
|
|
for(const auto & v : variations){
|
|
|
|
msdfVariations.push_back({v.name, v.value});
|
2023-04-06 11:17:22 +02:00
|
|
|
}
|
2023-04-13 17:15:35 +02:00
|
|
|
// 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();
|
|
|
|
}
|
2023-03-25 18:59:58 +01:00
|
|
|
}
|
2023-04-07 16:17:07 +02:00
|
|
|
return layerID;
|
|
|
|
}
|
|
|
|
|
2023-04-13 17:15:35 +02:00
|
|
|
void LayerComposition::removeLayer(const LayerID & id){
|
|
|
|
auto layer = getLayer(id);
|
|
|
|
for(auto & it : atlasLayerCombos){
|
|
|
|
it.second->abandonChild(layer);
|
|
|
|
}
|
|
|
|
layers.erase(id);
|
|
|
|
}
|
|
|
|
|
2023-04-07 16:17:07 +02:00
|
|
|
shared_ptr <Layer> LayerComposition::getLayer(const LayerID & layerID){
|
|
|
|
return layers[layerID];
|
2023-03-25 18:59:58 +01:00
|
|
|
}
|
|
|
|
|
2023-04-06 11:17:22 +02:00
|
|
|
void LayerComposition::draw() const {
|
|
|
|
for(const auto & layer_it : layers){
|
2023-04-12 13:59:09 +02:00
|
|
|
if(layer_it.second->getType() == Layer::MSDFGEN){
|
|
|
|
layer_it.second->draw(glm::vec3(200, 200, 0));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for(const auto & combo_it : atlasLayerCombos){
|
|
|
|
if(combo_it.first.type == Layer::GPUFONT){
|
|
|
|
auto combo =
|
|
|
|
static_pointer_cast <GPUFontAtlasLayerCombo>(combo_it.second);
|
|
|
|
combo->draw();
|
|
|
|
}
|
2023-04-06 11:17:22 +02:00
|
|
|
}
|
2023-03-25 18:59:58 +01:00
|
|
|
}
|
|
|
|
|
2023-04-11 12:23:14 +02:00
|
|
|
const unordered_map <ComboIdentifier, shared_ptr <AtlasLayerCombo> > & LayerComposition::getAtlasLayerCombos() const {
|
|
|
|
return atlasLayerCombos;
|
|
|
|
}
|
|
|
|
|
2023-04-11 13:17:30 +02:00
|
|
|
void LayerComposition::setVFlip(bool vFlip){
|
|
|
|
vFlipState = vFlip ? V_FLIP_ON : V_FLIP_OFF;
|
|
|
|
for(auto & layer : layers){
|
|
|
|
layer.second->setVFlip(vFlipState);
|
|
|
|
}
|
2023-04-12 15:47:01 +02:00
|
|
|
for(const auto & combo_it : atlasLayerCombos){
|
|
|
|
combo_it.second->setVFlip(vFlipState);
|
|
|
|
}
|
2023-04-11 13:17:30 +02:00
|
|
|
}
|
|
|
|
|
2023-03-25 18:59:58 +01:00
|
|
|
}
|