variablelab/ofxVariableLab
4
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

introduce layerOrder

Browse source
This commit is contained in:
jrkb 2023-05-14 08:33:23 +02:00
parent 976e309a54
commit 012987c11b
5 changed files with 298 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

278
src/GPUFontAtlasLayerCombo.cpp
View file

@ -39,19 +39,18 @@ void GPUFontAtlasLayerCombo::setup(const ComboIdentifier & identifier,
this->settings.gpuTextureOffset); this->settings.gpuTextureOffset);
font->listFontVariationAxes(fontVariationAxesParameters, library); font->listFontVariationAxes(fontVariationAxesParameters, library);
cout << this->identifier.fontPath << " : fontVariationAxes :" << endl; //cout << this->identifier.fontPath << " : fontVariationAxes :" << endl;
for(const auto & axis : fontVariationAxesParameters){ for(const auto & axis : fontVariationAxesParameters){
cout << std::fixed << std::setprecision(10) << axis.name << " :\n" //cout << std::fixed << std::setprecision(10) << axis.name << " :\n"
<< "\tmin: " << std::to_string(axis.minValue) //<< "\tmin: " << std::to_string(axis.minValue)
<< "\tmax: " << std::to_string(axis.maxValue) //<< "\tmax: " << std::to_string(axis.maxValue)
<< "\tdefault: " << std::to_string(axis.defaultValue) << endl; //<< "\tdefault: " << std::to_string(axis.defaultValue) << endl;
fontVariationAxes.push_back({axis.name, axis.defaultValue}); fontVariationAxes.push_back({axis.name, axis.defaultValue});
} }
transform = Transform(); transform = Transform();
auto & r = ofGetCurrentRenderer(); auto & r = ofGetCurrentRenderer();
cout << "Render type " << r->getType() << endl;
} }
void GPUFontAtlasLayerCombo::update(){ void GPUFontAtlasLayerCombo::update(){
OFX_PROFILER_FUNCTION(); OFX_PROFILER_FUNCTION();
@ -228,12 +227,12 @@ void GPUFontAtlasLayerCombo::draw(int width, int height){
layer->getVariationText(), layer->getVariationText(),
layer->getProps().width, layer->getProps().width,
lineHeight); lineHeight);
if(ofGetFrameNum() % 600 == 0){ //if(ofGetFrameNum() % 600 == 0){
cout //cout
<< "n_wraps: " << ofToString(n_wraps) << endl //<< "n_wraps: " << ofToString(n_wraps) << endl
<< "layer->getProps().width: " << ofToString(layer->getProps().width) << endl //<< "layer->getProps().width: " << ofToString(layer->getProps().width) << endl
; //;
}
//bb.p2.y += n_wraps * lineHeight; //bb.p2.y += n_wraps * lineHeight;
//bb.p3.y += n_wraps * lineHeight; //bb.p3.y += n_wraps * lineHeight;
glm::vec4 transformOrigin; glm::vec4 transformOrigin;
@ -358,11 +357,250 @@ void GPUFontAtlasLayerCombo::draw(int width, int height){
} }
glUseProgram(currentProgram); glUseProgram(currentProgram);
ofPushStyle(); //ofPushStyle();
ofSetColor(ofColor::green); //ofSetColor(ofColor::green);
ofNoFill(); //ofNoFill();
ofDrawRectangle(r); //ofDrawRectangle(r);
ofPopStyle(); //ofPopStyle();
//ofPushStyle();
//ofSetColor(ofColor::white);
//for(const auto & b : outerBoundingBoxes){
//int i = 0;
//for(const auto & v : b.getVertices()){
//ofSetColor(b.getColors()[i]);
//ofDrawCircle(v, 2);
//ofDrawBitmapString(ofToString(i), 0, 0);
//i++;
//}
//b.drawVertices();
//}
//ofFill();
//ofPopStyle();
}
glDisable(GL_BLEND);
}
void GPUFontAtlasLayerCombo::draw(int width,
int height,
const shared_ptr <GPUFontLayer> & layer){
OFX_PROFILER_FUNCTION();
GLuint location;
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);
//glClearColor(1.0f, 1.0f, 1.0f, 1.0f); // background color
//glClear(GL_COLOR_BUFFER_BIT); // clear background with background color
// Uses premultiplied-alpha.
ofDisableDepthTest();
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
//glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
//ofEnableAlphaBlending();
int currentProgram;
glGetIntegerv(GL_CURRENT_PROGRAM, &currentProgram);
//antiAliasingWindowSize = ofMap(ofGetMouseX(), 0, ofGetWidth(), 1, 3);
//enableSuperSamplingAntiAliasing = ofGetMouseY() > ofGetHeight() / 2;
if(font){
OFX_PROFILER_SCOPE("draw 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;
ofRectangle r;
//for(const auto & layer : layers)
{
OFX_PROFILER_SCOPE("draw layer");
float ascender = font->getAscender(layer->getProps().fontSize_px);
ofxGPUFont::Font::BoundingBox bb;
std::vector <ofxGPUFont::Font::BoundingBox> bbs;
std::vector <ofxGPUFont::Font::BoundingBox> mirror_bbs;
float advanceY = 0;
font->collectBoundingBoxes(layer->getVariationText(),
layer->getVariationTextAppearance(),
bb, bbs, advanceY,
true, layer->getProps().fontSize_px,
layer->getProps().lineHeight);
float lineHeight = font->getLineHeight(layer->getProps().fontSize_px) * layer->getProps().lineHeight;
int n_wraps = wrapBoundingBoxes(bbs,
layer->getVariationText(),
layer->getProps().width,
lineHeight);
//if(ofGetFrameNum() % 600 == 0){
//cout
//<< "n_wraps: " << ofToString(n_wraps) << endl
//<< "layer->getProps().width: " << ofToString(layer->getProps().width) << endl
//;
//}
//bb.p2.y += n_wraps * lineHeight;
//bb.p3.y += n_wraps * lineHeight;
glm::vec4 transformOrigin;
getAndApplyTransformOrigin(transformOrigin,
layer->getOuterNode(),
layer->getInnerNode(),
bb,
ascender,
advanceY,
layer->getProps());
auto bb_mirror_none = bb;
bb_mirror_none.multiply(layer->getInnerNode().getGlobalTransformMatrix());
mirror_bbs.push_back(std::move(bb_mirror_none));
//layer->setBoundingBox(bb);
ofVboMesh mesh;
mesh.addVertices({bb_mirror_none.p0,
bb_mirror_none.p1,
bb_mirror_none.p2,
bb_mirror_none.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);
if(layer->getProps().mirror_x){
auto bbs_mirror_x = bbs;
ofNode mirrorOuterNode = layer->getOuterNode();
ofNode mirrorInnerNode = layer->getInnerNode();
mirrorInnerNode.setParent(mirrorOuterNode);
mirrorOuterNode.setOrientation(glm::quat(1, 0, 0, 0));
mirrorOuterNode.rotateDeg(layer->getProps().rotation * -1, glm::vec3(0, 0, 1));
mirrorOuterNode.setPosition(transformOrigin);
mirrorOuterNode.move(layer->getProps().mirror_x_distance * -1, 0, 0);
mirrorOuterNode.setScale(-1, 1, 1);
auto bb_mirror_x = bb;
bb_mirror_x.multiply(mirrorInnerNode.getGlobalTransformMatrix());
mirror_bbs.push_back(std::move(bb_mirror_x));
font->collectVerticesAndIndices(mirrorInnerNode,
layer->getVariationTextAppearance(),
bbs_mirror_x,
vertices,
indices);
}
if(layer->getProps().mirror_y){
auto bbs_mirror_y = bbs;
ofNode mirrorOuterNode = layer->getOuterNode();
ofNode mirrorInnerNode = layer->getInnerNode();
mirrorInnerNode.setParent(mirrorOuterNode);
mirrorOuterNode.setOrientation(glm::quat(1, 0, 0, 0));
mirrorOuterNode.rotateDeg(layer->getProps().rotation * -1, glm::vec3(0, 0, 1));
mirrorOuterNode.setPosition(transformOrigin);
mirrorOuterNode.move(0, layer->getProps().mirror_y_distance * -1, 0);
mirrorOuterNode.setScale(1, -1, 1);
auto bb_mirror_y = bb;
bb_mirror_y.multiply(mirrorInnerNode.getGlobalTransformMatrix());
mirror_bbs.push_back(std::move(bb_mirror_y));
font->collectVerticesAndIndices(mirrorInnerNode,
layer->getVariationTextAppearance(),
bbs_mirror_y,
vertices,
indices);
}
if(layer->getProps().mirror_xy){
auto bbs_mirror_xy = bbs;
ofNode mirrorOuterNode = layer->getOuterNode();
ofNode mirrorInnerNode = layer->getInnerNode();
mirrorInnerNode.setParent(mirrorOuterNode);
mirrorOuterNode.setOrientation(glm::quat(1, 0, 0, 0));
mirrorOuterNode.rotateDeg(layer->getProps().rotation * 1, glm::vec3(0, 0, 1));
mirrorOuterNode.setPosition(transformOrigin);
mirrorOuterNode.move(layer->getProps().mirror_x_distance * -1,
layer->getProps().mirror_y_distance * -1, 0);
mirrorOuterNode.setScale(-1, -1, 1);
auto bb_mirror_xy = bb;
bb_mirror_xy.multiply(mirrorInnerNode.getGlobalTransformMatrix());
mirror_bbs.push_back(std::move(bb_mirror_xy));
font->collectVerticesAndIndices(mirrorInnerNode,
layer->getVariationTextAppearance(),
bbs_mirror_xy,
vertices,
indices);
}
font->collectVerticesAndIndices(layer->getInnerNode(),
layer->getVariationTextAppearance(),
bbs,
vertices,
indices);
float min_x = FLT_MAX;
float max_x = -FLT_MAX;
float min_y = FLT_MAX;
float max_y = -FLT_MAX;
for(const auto & mbb : mirror_bbs){
min_x = min(min_x, min(mbb.p0.x, min(mbb.p1.x, min(mbb.p2.x, mbb.p3.x))));
max_x = max(max_x, max(mbb.p0.x, max(mbb.p1.x, max(mbb.p2.x, mbb.p3.x))));
min_y = min(min_y, min(mbb.p0.y, min(mbb.p1.y, min(mbb.p2.y, mbb.p3.y))));
max_y = max(max_y, max(mbb.p0.y, max(mbb.p1.y, max(mbb.p2.y, mbb.p3.y))));
}
float width = max_x - min_x;
float height = max_y - min_y;
layer->setBoundingBox(Layer::BoundingBox{min_x, min_y, width, height});
r = ofRectangle(layer->getProps().x, layer->getProps().y, layer->getProps().width, 800);
}
{
OFX_PROFILER_SCOPE("font->draw()");
font->draw(vertices, indices);
}
glUseProgram(currentProgram);
//ofPushStyle();
//ofSetColor(ofColor::green);
//ofNoFill();
//ofDrawRectangle(r);
//ofPopStyle();
//ofPushStyle(); //ofPushStyle();
//ofSetColor(ofColor::white); //ofSetColor(ofColor::white);
//for(const auto & b : outerBoundingBoxes){ //for(const auto & b : outerBoundingBoxes){
@ -483,9 +721,9 @@ int GPUFontAtlasLayerCombo::wrapBoundingBoxes(std::vector <ofxGPUFont::Font::Bou
wrapIndex = i; wrapIndex = i;
} }
float xxx = bb.p1.x - collectedWrapWidth; float xxx = bb.p1.x - collectedWrapWidth;
if(ofGetFrameNum() % 600 == 0){ //if(ofGetFrameNum() % 600 == 0){
cout << "WRAP INDEX " << char(variationText[vi].charcode) << ":" << ofToString(wrapIndex) << " xxx: " << ofToString(xxx) << " cww: " << ofToString(collectedWrapWidth) << endl; //cout << "WRAP INDEX " << char(variationText[vi].charcode) << ":" << ofToString(wrapIndex) << " xxx: " << ofToString(xxx) << " cww: " << ofToString(collectedWrapWidth) << endl;
} //}
if(bb.p1.x - collectedWrapWidth > width){ if(bb.p1.x - collectedWrapWidth > width){
if(wrapIndex >= 0){ if(wrapIndex >= 0){
if(wrapIndex == i){ if(wrapIndex == i){

3
src/GPUFontAtlasLayerCombo.h
View file

@ -6,6 +6,7 @@
#include "AtlasLayerCombo.h" #include "AtlasLayerCombo.h"
#include "GPUFontLayer.h" #include "GPUFontLayer.h"
#include "ofxProfiler.h" #include "ofxProfiler.h"
#include <memory>
#ifdef TARGET_EMSCRIPTEN #ifdef TARGET_EMSCRIPTEN
#include <GLES/gl.h> #include <GLES/gl.h>
#include <emscripten/emscripten.h> #include <emscripten/emscripten.h>
@ -77,6 +78,8 @@ class GPUFontAtlasLayerCombo : public AtlasLayerCombo {
const vector <shared_ptr <GPUFontLayer> > & getLayers(); const vector <shared_ptr <GPUFontLayer> > & getLayers();
void draw(int width, int height); void draw(int width, int height);
void draw(int width, int height,
const shared_ptr <GPUFontLayer> & layer);
shared_ptr <ofxGPUFont::Font> font; shared_ptr <ofxGPUFont::Font> font;
string mainText = ""; string mainText = "";

1
src/Layer.h
View file

@ -45,6 +45,7 @@ class Layer {
float letterDelay = 0; float letterDelay = 0;
int transformOrigin = TransformOrigin::TOP_LEFT; int transformOrigin = TransformOrigin::TOP_LEFT;
std::vector <ofxVariableLab::FontVariation> fontVariations; std::vector <ofxVariableLab::FontVariation> fontVariations;
std::map <string, float> letterDelays;
string text = "abc"; string text = "abc";
string fontPath = "data/celines-fonts/Version-2-var.ttf"; string fontPath = "data/celines-fonts/Version-2-var.ttf";
//NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Props, //NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Props,

47
src/LayerComposition.cpp
View file

@ -1,6 +1,7 @@
#include "LayerComposition.h" #include "LayerComposition.h"
#include "Atlas.h" #include "Atlas.h"
#include "GPUFontAtlasLayerCombo.h" #include "GPUFontAtlasLayerCombo.h"
#include "GPUFontLayer.h"
#include "MsdfLayer.h" #include "MsdfLayer.h"
#include "Utils.h" #include "Utils.h"
#include "ofUtils.h" #include "ofUtils.h"
@ -23,9 +24,9 @@ void LayerComposition::update(){
l.second->getProps().fontPath, l.second->getProps().fontPath,
momIdentifier.type momIdentifier.type
}; };
cout << "ideal mom looks like this: " << l.second->getProps().fontPath //cout << "ideal mom looks like this: " << l.second->getProps().fontPath
<< (momIdentifier.type == LayerType::GPUFONT ? " gpufont" : " msdfgen") //<< (momIdentifier.type == LayerType::GPUFONT ? " gpufont" : " msdfgen")
<< endl; //<< endl;
findOrCreateNewMomForLayer(l.second, idealMom); findOrCreateNewMomForLayer(l.second, idealMom);
} }
} }
@ -119,7 +120,6 @@ LayerID LayerComposition::addLayer(const ComboIdentifier & identifier,
layer->setup(); layer->setup();
if(layerID == ""){ if(layerID == ""){
layerID = layer->getId(); layerID = layer->getId();
cout << "yess layerID is now " << layerID << "!" << endl;
}else{ }else{
layer->setId(layerID); layer->setId(layerID);
} }
@ -176,18 +176,33 @@ shared_ptr <Layer> LayerComposition::getLayer(const LayerID & layerID){
} }
void LayerComposition::draw(int width, int height) const { void LayerComposition::draw(int width, int height) const {
for(const auto & layer_it : layers){ for(unsigned int i = layerOrder.size(); i-- > 0;){
if(layer_it.second->getType() == LayerType::MSDFGEN){ LayerID layerID = layerOrder[i];
layer_it.second->draw(glm::vec3(200, 200, 0)); if(layers.count(layerID) > 0){
} auto layer = layers.at(layerID);
} if(layers.at(layerID)->getType() == LayerType::MSDFGEN){
for(const auto & combo_it : atlasLayerCombos){ layer->draw(glm::vec3(200, 200, 0));
if(combo_it.first.type == LayerType::GPUFONT){ }else{
auto combo = auto combo =
static_pointer_cast <GPUFontAtlasLayerCombo>(combo_it.second); static_pointer_cast <GPUFontAtlasLayerCombo>(atlasLayerCombos.at(layer->getMomsComboIdentifier()));
combo->draw(width, height); auto gpulayer =
static_pointer_cast <GPUFontLayer>(layer);
combo->draw(width, height, gpulayer);
}
} }
} }
//for(const auto & layer_it : layers){
//if(layer_it.second->getType() == LayerType::MSDFGEN){
//layer_it.second->draw(glm::vec3(200, 200, 0));
//}
//}
//for(const auto & combo_it : atlasLayerCombos){
//if(combo_it.first.type == LayerType::GPUFONT){
//auto combo =
//static_pointer_cast <GPUFontAtlasLayerCombo>(combo_it.second);
//combo->draw(width, height);
//}
//}
} }
const unordered_map <ComboIdentifier, shared_ptr <AtlasLayerCombo> > & LayerComposition::getAtlasLayerCombos() const { const unordered_map <ComboIdentifier, shared_ptr <AtlasLayerCombo> > & LayerComposition::getAtlasLayerCombos() const {
@ -204,4 +219,8 @@ void LayerComposition::setVFlip(bool vFlip){
} }
} }
void LayerComposition::setLayerOrder(const vector <LayerID> & layerOrder){
this->layerOrder = layerOrder;
}
} }

3
src/LayerComposition.h
View file

@ -33,10 +33,13 @@ class LayerComposition {
const unordered_map <ComboIdentifier, shared_ptr <AtlasLayerCombo> > & getAtlasLayerCombos() const; const unordered_map <ComboIdentifier, shared_ptr <AtlasLayerCombo> > & getAtlasLayerCombos() const;
void setVFlip(bool vFlip); void setVFlip(bool vFlip);
void setLayerOrder(const vector <LayerID> & layerOrder);
private: private:
VFlipState vFlipState = V_FLIP_UNKNOWN; VFlipState vFlipState = V_FLIP_UNKNOWN;
unordered_map <LayerID, shared_ptr <Layer> > layers; unordered_map <LayerID, shared_ptr <Layer> > layers;
unordered_map <LayerID, shared_ptr <AtlasLayerCombo> > layerIDcombos;
unordered_map <ComboIdentifier, shared_ptr <AtlasLayerCombo> > atlasLayerCombos; unordered_map <ComboIdentifier, shared_ptr <AtlasLayerCombo> > atlasLayerCombos;
vector <LayerID> layerOrder;
/** /**
* @brief lastGpuTextureOffset GL_TEXTURE0 + offset * @brief lastGpuTextureOffset GL_TEXTURE0 + offset