mirror of
https://github.com/wiiu-env/libgui.git
synced 2024-11-15 04:45:06 +01:00
707 lines
18 KiB
C++
707 lines
18 KiB
C++
/****************************************************************************
|
|
* Copyright (C) 2015 Dimok
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
****************************************************************************/
|
|
#include <gui/GuiText.h>
|
|
#include <gui/FreeTypeGX.h>
|
|
#include <gui/video/CVideo.h>
|
|
|
|
FreeTypeGX *GuiText::presentFont = NULL;
|
|
int32_t GuiText::presetSSAA = 2;
|
|
int32_t GuiText::presetSize = 28;
|
|
int32_t GuiText::presetMaxWidth = 0xFFFF;
|
|
int32_t GuiText::presetAlignment = ALIGN_CENTER | ALIGN_MIDDLE;
|
|
GX2ColorF32 GuiText::presetColor = (GX2ColorF32) {
|
|
1.0f, 1.0f, 1.0f, 1.0f
|
|
};
|
|
|
|
#define TEXT_SCROLL_DELAY 6
|
|
#define TEXT_SCROLL_INITIAL_DELAY 10
|
|
#define MAX_LINES_TO_DRAW 10
|
|
|
|
/**
|
|
* Constructor for the GuiText class.
|
|
*/
|
|
|
|
GuiText::GuiText() {
|
|
text = NULL;
|
|
currentSize = presetSize;
|
|
color = glm::vec4(presetColor.r, presetColor.g, presetColor.b, presetColor.a);
|
|
alpha = presetColor.a;
|
|
alignment = presetAlignment;
|
|
maxWidth = presetMaxWidth;
|
|
internalSSAA = presetSSAA;
|
|
wrapMode = 0;
|
|
font = presentFont;
|
|
linestodraw = MAX_LINES_TO_DRAW;
|
|
textScrollPos = 0;
|
|
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
|
|
textScrollDelay = TEXT_SCROLL_DELAY;
|
|
defaultBlur = 4.0f;
|
|
blurGlowIntensity = 0.0f;
|
|
blurAlpha = 0.0f;
|
|
blurGlowColor = glm::vec4(0.0f);
|
|
width = 0;
|
|
height = 0;
|
|
}
|
|
|
|
GuiText::GuiText(const char *t, int32_t s, const glm::vec4 &c) {
|
|
text = NULL;
|
|
currentSize = s;
|
|
color = c;
|
|
alpha = c[3];
|
|
alignment = ALIGN_CENTER | ALIGN_MIDDLE;
|
|
maxWidth = presetMaxWidth;
|
|
internalSSAA = presetSSAA;
|
|
wrapMode = 0;
|
|
font = presentFont;
|
|
linestodraw = MAX_LINES_TO_DRAW;
|
|
textScrollPos = 0;
|
|
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
|
|
textScrollDelay = TEXT_SCROLL_DELAY;
|
|
defaultBlur = 4.0f;
|
|
blurGlowIntensity = 0.0f;
|
|
blurAlpha = 0.0f;
|
|
blurGlowColor = glm::vec4(0.0f);
|
|
width = 0;
|
|
height = 0;
|
|
|
|
if (t) {
|
|
textMutex.lock();
|
|
text = FreeTypeGX::charToWideChar(t);
|
|
textMutex.unlock();
|
|
}
|
|
}
|
|
|
|
GuiText::GuiText(const wchar_t *t, int32_t s, const glm::vec4 &c) {
|
|
text = NULL;
|
|
currentSize = s;
|
|
color = c;
|
|
alpha = c[3];
|
|
alignment = ALIGN_CENTER | ALIGN_MIDDLE;
|
|
maxWidth = presetMaxWidth;
|
|
internalSSAA = presetSSAA;
|
|
wrapMode = 0;
|
|
font = presentFont;
|
|
linestodraw = MAX_LINES_TO_DRAW;
|
|
textScrollPos = 0;
|
|
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
|
|
textScrollDelay = TEXT_SCROLL_DELAY;
|
|
defaultBlur = 4.0f;
|
|
blurGlowIntensity = 0.0f;
|
|
blurAlpha = 0.0f;
|
|
blurGlowColor = glm::vec4(0.0f);
|
|
width = 0;
|
|
height = 0;
|
|
|
|
if (t) {
|
|
textMutex.lock();
|
|
text = new(std::nothrow) wchar_t[wcslen(t) + 1];
|
|
if (!text) {
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
wcscpy(text, t);
|
|
textMutex.unlock();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Constructor for the GuiText class, uses presets
|
|
*/
|
|
GuiText::GuiText(const char *t) {
|
|
text = NULL;
|
|
currentSize = presetSize;
|
|
color = glm::vec4(presetColor.r, presetColor.g, presetColor.b, presetColor.a);
|
|
alpha = presetColor.a;
|
|
alignment = presetAlignment;
|
|
maxWidth = presetMaxWidth;
|
|
internalSSAA = presetSSAA;
|
|
wrapMode = 0;
|
|
font = presentFont;
|
|
linestodraw = MAX_LINES_TO_DRAW;
|
|
textScrollPos = 0;
|
|
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
|
|
textScrollDelay = TEXT_SCROLL_DELAY;
|
|
defaultBlur = 4.0f;
|
|
blurGlowIntensity = 0.0f;
|
|
blurAlpha = 0.0f;
|
|
blurGlowColor = glm::vec4(0.0f);
|
|
width = 0;
|
|
height = 0;
|
|
|
|
if (t) {
|
|
textMutex.lock();
|
|
text = FreeTypeGX::charToWideChar(t);
|
|
textMutex.unlock();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Destructor for the GuiText class.
|
|
*/
|
|
GuiText::~GuiText() {
|
|
textMutex.lock();
|
|
if (text) {
|
|
delete[] text;
|
|
}
|
|
text = NULL;
|
|
textMutex.unlock();
|
|
|
|
clearDynamicText();
|
|
}
|
|
|
|
void GuiText::setText(const char *t) {
|
|
textMutex.lock();
|
|
if (text) {
|
|
delete[] text;
|
|
}
|
|
text = NULL;
|
|
|
|
clearDynamicText();
|
|
|
|
textScrollPos = 0;
|
|
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
|
|
|
|
if (t) {
|
|
text = FreeTypeGX::charToWideChar(t);
|
|
}
|
|
textMutex.unlock();
|
|
}
|
|
|
|
void GuiText::setTextf(const char *format, ...) {
|
|
if (!format) {
|
|
setText((char *) NULL);
|
|
return;
|
|
}
|
|
|
|
int32_t max_len = strlen(format) + 8192;
|
|
char *tmp = new char[max_len];
|
|
va_list va;
|
|
va_start(va, format);
|
|
if ((vsnprintf(tmp, max_len, format, va) >= 0) && tmp) {
|
|
setText(tmp);
|
|
}
|
|
va_end(va);
|
|
|
|
if (tmp) {
|
|
delete[] tmp;
|
|
}
|
|
}
|
|
|
|
|
|
void GuiText::setText(const wchar_t *t) {
|
|
textMutex.lock();
|
|
if (text) {
|
|
delete[] text;
|
|
}
|
|
text = NULL;
|
|
|
|
clearDynamicText();
|
|
|
|
textScrollPos = 0;
|
|
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
|
|
|
|
if (t) {
|
|
text = new(std::nothrow) wchar_t[wcslen(t) + 1];
|
|
if (!text) {
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
wcscpy(text, t);
|
|
}
|
|
textMutex.unlock();
|
|
}
|
|
|
|
void GuiText::clearDynamicText() {
|
|
textMutex.lock();
|
|
for (uint32_t i = 0; i < textDyn.size(); i++) {
|
|
if (textDyn[i]) {
|
|
delete[] textDyn[i];
|
|
}
|
|
}
|
|
textDyn.clear();
|
|
textDynWidth.clear();
|
|
textMutex.unlock();
|
|
}
|
|
|
|
void GuiText::setPresets(int32_t sz, const glm::vec4 &c, int32_t w, int32_t a) {
|
|
presetSize = sz;
|
|
presetColor = (GX2ColorF32) {
|
|
(float) c.r / 255.0f, (float) c.g / 255.0f, (float) c.b / 255.0f, (float) c.a / 255.0f
|
|
};
|
|
presetMaxWidth = w;
|
|
presetAlignment = a;
|
|
}
|
|
|
|
void GuiText::setPresetFont(FreeTypeGX *f) {
|
|
presentFont = f;
|
|
}
|
|
|
|
void GuiText::setFontSize(int32_t s) {
|
|
currentSize = s;
|
|
}
|
|
|
|
void GuiText::setMaxWidth(int32_t width, int32_t w) {
|
|
maxWidth = width;
|
|
wrapMode = w;
|
|
|
|
if (w == SCROLL_HORIZONTAL) {
|
|
textScrollPos = 0;
|
|
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
|
|
textScrollDelay = TEXT_SCROLL_DELAY;
|
|
}
|
|
|
|
clearDynamicText();
|
|
}
|
|
|
|
void GuiText::setColor(const glm::vec4 &c) {
|
|
color = c;
|
|
alpha = c[3];
|
|
}
|
|
|
|
void GuiText::setBlurGlowColor(float blur, const glm::vec4 &c) {
|
|
blurGlowColor = c;
|
|
blurGlowIntensity = blur;
|
|
blurAlpha = c[3];
|
|
}
|
|
|
|
int32_t GuiText::getTextWidth(int32_t ind) {
|
|
textMutex.lock();
|
|
int32_t res;
|
|
if (ind < 0 || ind >= (int32_t) textDyn.size()) {
|
|
res = this->getTextWidth();
|
|
} else {
|
|
res = font->getWidth(textDyn[ind], currentSize);
|
|
}
|
|
textMutex.unlock();
|
|
return res;
|
|
}
|
|
|
|
//!Get the Horizontal Size of Text
|
|
int32_t GuiText::getTextWidth() {
|
|
textMutex.lock();
|
|
auto res = font->getWidth(text, currentSize);
|
|
res = res > maxWidth && maxWidth > 0 ? maxWidth : res;
|
|
textMutex.unlock();
|
|
return res;
|
|
}
|
|
|
|
float GuiText::getTextHeight() {
|
|
textMutex.lock();
|
|
if (wrapMode == GuiText::WRAP && textDyn.empty()) {
|
|
if (maxWidth > 0 && font->getWidth(text, currentSize)) {
|
|
wrapText();
|
|
}
|
|
}
|
|
|
|
auto res = textDyn.empty() ? getLineHeight() : getLineHeight() * textDyn.size();
|
|
textMutex.unlock();
|
|
return res;
|
|
}
|
|
|
|
const wchar_t *GuiText::getDynText(int32_t ind) {
|
|
textMutex.lock();
|
|
const wchar_t *result;
|
|
if (ind < 0 || ind >= (int32_t) textDyn.size()) {
|
|
result = text;
|
|
} else {
|
|
result = textDyn[ind];
|
|
}
|
|
textMutex.unlock();
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Change font
|
|
*/
|
|
bool GuiText::setFont(FreeTypeGX *f) {
|
|
if (!f) {
|
|
return false;
|
|
}
|
|
|
|
font = f;
|
|
return true;
|
|
}
|
|
|
|
std::string GuiText::toUTF8(void) const {
|
|
textMutex.lock();
|
|
if (!text) {
|
|
textMutex.unlock();
|
|
return std::string();
|
|
}
|
|
|
|
char *pUtf8 = FreeTypeGX::wideCharToUTF8(text);
|
|
textMutex.unlock();
|
|
if (!pUtf8) {
|
|
return std::string();
|
|
}
|
|
|
|
std::string strOutput(pUtf8);
|
|
|
|
delete[] pUtf8;
|
|
|
|
return strOutput;
|
|
}
|
|
|
|
void GuiText::makeDottedText() {
|
|
textMutex.lock();
|
|
int32_t pos = textDyn.size();
|
|
textDyn.resize(pos + 1);
|
|
|
|
int32_t i = 0, currentWidth = 0;
|
|
textDyn[pos] = new(std::nothrow) wchar_t[maxWidth];
|
|
if (!textDyn[pos]) {
|
|
textDyn.resize(pos);
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
while (text[i]) {
|
|
currentWidth += font->getCharWidth(text[i], currentSize, i > 0 ? text[i - 1] : 0);
|
|
if (currentWidth >= maxWidth && i > 2) {
|
|
textDyn[pos][i - 2] = '.';
|
|
textDyn[pos][i - 1] = '.';
|
|
textDyn[pos][i] = '.';
|
|
i++;
|
|
break;
|
|
}
|
|
|
|
textDyn[pos][i] = text[i];
|
|
|
|
i++;
|
|
}
|
|
textDyn[pos][i] = 0;
|
|
textMutex.unlock();
|
|
}
|
|
|
|
void GuiText::scrollText(uint32_t frameCount) {
|
|
textMutex.lock();
|
|
if (textDyn.size() == 0) {
|
|
int32_t pos = textDyn.size();
|
|
int32_t i = 0, currentWidth = 0;
|
|
textDyn.resize(pos + 1);
|
|
|
|
textDyn[pos] = new(std::nothrow) wchar_t[maxWidth];
|
|
if (!textDyn[pos]) {
|
|
textDyn.resize(pos);
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
while (text[i] && currentWidth < maxWidth) {
|
|
textDyn[pos][i] = text[i];
|
|
|
|
currentWidth += font->getCharWidth(text[i], currentSize, i > 0 ? text[i - 1] : 0);
|
|
|
|
++i;
|
|
}
|
|
textDyn[pos][i] = 0;
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
if (frameCount % textScrollDelay != 0) {
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
if (textScrollInitialDelay) {
|
|
--textScrollInitialDelay;
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
int32_t stringlen = wcslen(text);
|
|
|
|
++textScrollPos;
|
|
if (textScrollPos > stringlen) {
|
|
textScrollPos = 0;
|
|
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
|
|
}
|
|
|
|
int32_t ch = textScrollPos;
|
|
int32_t pos = textDyn.size() - 1;
|
|
|
|
if (!textDyn[pos]) {
|
|
textDyn[pos] = new(std::nothrow) wchar_t[maxWidth];
|
|
}
|
|
|
|
if (!textDyn[pos]) {
|
|
textDyn.resize(pos);
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
int32_t i = 0, currentWidth = 0;
|
|
|
|
while (currentWidth < maxWidth) {
|
|
if (ch > stringlen - 1) {
|
|
textDyn[pos][i++] = ' ';
|
|
currentWidth += font->getCharWidth(L' ', currentSize, ch > 0 ? text[ch - 1] : 0);
|
|
textDyn[pos][i++] = ' ';
|
|
currentWidth += font->getCharWidth(L' ', currentSize, L' ');
|
|
textDyn[pos][i++] = ' ';
|
|
currentWidth += font->getCharWidth(L' ', currentSize, L' ');
|
|
ch = 0;
|
|
|
|
if (currentWidth >= maxWidth) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
textDyn[pos][i] = text[ch];
|
|
currentWidth += font->getCharWidth(text[ch], currentSize, ch > 0 ? text[ch - 1] : 0);
|
|
++ch;
|
|
++i;
|
|
}
|
|
textDyn[pos][i] = 0;
|
|
textMutex.unlock();
|
|
}
|
|
|
|
void GuiText::wrapText() {
|
|
textMutex.lock();
|
|
if (textDyn.size() > 0) {
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
int32_t i = 0;
|
|
int32_t ch = 0;
|
|
int32_t linenum = 0;
|
|
int32_t lastSpace = -1;
|
|
int32_t lastSpaceIndex = -1;
|
|
int32_t currentWidth = 0;
|
|
|
|
while (text[ch] && linenum < linestodraw) {
|
|
if (linenum >= (int32_t) textDyn.size()) {
|
|
textDyn.resize(linenum + 1);
|
|
textDyn[linenum] = new(std::nothrow) wchar_t[maxWidth];
|
|
if (!textDyn[linenum]) {
|
|
textDyn.resize(linenum);
|
|
break;
|
|
}
|
|
}
|
|
|
|
textDyn[linenum][i] = text[ch];
|
|
textDyn[linenum][i + 1] = 0;
|
|
|
|
currentWidth += font->getCharWidth(text[ch], currentSize, ch > 0 ? text[ch - 1] : 0x0000);
|
|
|
|
if (currentWidth >= maxWidth || (text[ch] == '\n')) {
|
|
if (text[ch] == '\n') {
|
|
lastSpace = -1;
|
|
lastSpaceIndex = -1;
|
|
} else if (lastSpace >= 0) {
|
|
textDyn[linenum][lastSpaceIndex] = 0; // discard space, and everything after
|
|
ch = lastSpace; // go backwards to the last space
|
|
lastSpace = -1; // we have used this space
|
|
lastSpaceIndex = -1;
|
|
}
|
|
|
|
if (linenum + 1 == linestodraw && text[ch + 1] != 0x0000) {
|
|
if (i < 2) {
|
|
i = 2;
|
|
}
|
|
|
|
textDyn[linenum][i - 2] = '.';
|
|
textDyn[linenum][i - 1] = '.';
|
|
textDyn[linenum][i] = '.';
|
|
textDyn[linenum][i + 1] = 0;
|
|
}
|
|
|
|
currentWidth = 0;
|
|
++linenum;
|
|
i = -1;
|
|
}
|
|
if (text[ch] == ' ' && i >= 0) {
|
|
lastSpace = ch;
|
|
lastSpaceIndex = i;
|
|
}
|
|
++ch;
|
|
++i;
|
|
}
|
|
textMutex.unlock();
|
|
}
|
|
|
|
/**
|
|
* We need to redefine this, because we don't want to use our width.
|
|
*/
|
|
float GuiText::getCenterX(void) {
|
|
float pCenterX = 0.0f;
|
|
|
|
if (parentElement) {
|
|
pCenterX = parentElement->getCenterX();
|
|
}
|
|
|
|
pCenterX += xoffset + xoffsetDyn;
|
|
|
|
if (alignment & ALIGN_LEFT) {
|
|
float pWidth = 0.0f;
|
|
float pScale = 0.0f;
|
|
|
|
if (parentElement) {
|
|
pWidth = parentElement->getWidth();
|
|
pScale = parentElement->getScaleX();
|
|
}
|
|
|
|
pCenterX -= pWidth * 0.5f * pScale;
|
|
} else if (alignment & ALIGN_RIGHT) {
|
|
float pWidth = 0.0f;
|
|
float pScale = 0.0f;
|
|
|
|
if (parentElement) {
|
|
pWidth = parentElement->getWidth();
|
|
pScale = parentElement->getScaleX();
|
|
}
|
|
|
|
pCenterX += pWidth * 0.5f * pScale;
|
|
}
|
|
return pCenterX;
|
|
}
|
|
|
|
/**
|
|
* We need to redefine this, because we don't want to use our height.
|
|
*/
|
|
float GuiText::getCenterY(void) {
|
|
float pCenterY = 0.0f;
|
|
|
|
if (parentElement) {
|
|
pCenterY = parentElement->getCenterY();
|
|
}
|
|
|
|
pCenterY += yoffset + yoffsetDyn;
|
|
|
|
if (alignment & ALIGN_TOP) {
|
|
float pHeight = 0.0f;
|
|
float pScale = 0.0f;
|
|
|
|
if (parentElement) {
|
|
pHeight = parentElement->getHeight();
|
|
pScale = parentElement->getScaleY();
|
|
}
|
|
|
|
pCenterY += pHeight * 0.5f * pScale;
|
|
} else if (alignment & ALIGN_BOTTOM) {
|
|
float pHeight = 0.0f;
|
|
float pScale = 0.0f;
|
|
|
|
if (parentElement) {
|
|
pHeight = parentElement->getHeight();
|
|
pScale = parentElement->getScaleY();
|
|
}
|
|
|
|
pCenterY -= pHeight * 0.5f * pScale;
|
|
}
|
|
return pCenterY;
|
|
}
|
|
|
|
/**
|
|
* Draw the text on screen
|
|
*/
|
|
void GuiText::draw(CVideo *pVideo) {
|
|
textMutex.lock();
|
|
if (!text) {
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
if (!isVisible()) {
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
|
|
color[3] = getAlpha();
|
|
blurGlowColor[3] = blurAlpha * getAlpha();
|
|
|
|
auto internalRenderingScale = internalSSAA == 0 ? 1 : internalSSAA << 1;
|
|
|
|
int32_t normal_size = currentSize * getScale();
|
|
int32_t internalRenderingSize = normal_size * internalRenderingScale;
|
|
|
|
auto textWidth = font->getWidth(text, normal_size);
|
|
|
|
float x_pos = getCenterX() * internalRenderingScale;
|
|
float y_pos = getCenterY() * internalRenderingScale;
|
|
|
|
if (alignment & ALIGN_TOP) {
|
|
y_pos -= getLineHeight() * getScale() * internalRenderingScale;
|
|
} else if (alignment & ALIGN_BOTTOM) {
|
|
y_pos += getLineHeight() * getScale() * internalRenderingScale;
|
|
}
|
|
|
|
if (maxWidth > 0 && maxWidth <= textWidth) {
|
|
if (wrapMode == DOTTED) { // text dotted
|
|
if (textDyn.size() == 0) {
|
|
makeDottedText();
|
|
}
|
|
|
|
if (textDynWidth.size() != textDyn.size()) {
|
|
textDynWidth.resize(textDyn.size());
|
|
|
|
for (uint32_t i = 0; i < textDynWidth.size(); i++) {
|
|
textDynWidth[i] = font->getWidth(textDyn[i], internalRenderingSize);
|
|
}
|
|
}
|
|
|
|
|
|
if (textDyn.size() > 0) {
|
|
font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size() - 1], internalRenderingSize, color, alignment, textDynWidth[textDyn.size() - 1], defaultBlur, blurGlowIntensity, blurGlowColor, internalRenderingScale);
|
|
}
|
|
textMutex.unlock();
|
|
return;
|
|
} else if (wrapMode == SCROLL_HORIZONTAL) {
|
|
scrollText(pVideo->getFrameCount());
|
|
|
|
if (textDyn.size() > 0) {
|
|
font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size() - 1], internalRenderingSize, color, alignment, maxWidth * internalRenderingScale * getScale(), defaultBlur, blurGlowIntensity, blurGlowColor,
|
|
internalRenderingScale);
|
|
}
|
|
textMutex.unlock();
|
|
return;
|
|
} else if (wrapMode == WRAP) {
|
|
if (textDyn.size() == 0) {
|
|
wrapText();
|
|
}
|
|
|
|
if (textDynWidth.size() != textDyn.size()) {
|
|
textDynWidth.resize(textDyn.size());
|
|
|
|
for (uint32_t i = 0; i < textDynWidth.size(); i++) {
|
|
textDynWidth[i] = font->getWidth(textDyn[i], internalRenderingSize);
|
|
}
|
|
}
|
|
|
|
float voffset = 0.0f;
|
|
if (alignment & ALIGN_MIDDLE) {
|
|
voffset = (float) (((int32_t) getLineHeight() * (textDyn.size() - 1)) >> 1) * internalRenderingScale;
|
|
}
|
|
float y_offset = 0.0f;
|
|
for (uint32_t i = 0; i < textDyn.size(); i++) {
|
|
font->drawText(pVideo, x_pos, y_pos + y_offset + voffset, getDepth(), textDyn[i], internalRenderingSize, color, alignment, textDynWidth[i], defaultBlur, blurGlowIntensity, blurGlowColor, internalRenderingScale);
|
|
y_offset -= getLineHeight() * getScale() * internalRenderingScale;
|
|
}
|
|
textMutex.unlock();
|
|
return;
|
|
}
|
|
}
|
|
auto newTextWidth = font->getWidth(text, internalRenderingSize);
|
|
font->drawText(pVideo, x_pos, y_pos, getDepth(), text, internalRenderingSize, color, alignment, newTextWidth, defaultBlur, blurGlowIntensity, blurGlowColor, internalRenderingScale);
|
|
textMutex.unlock();
|
|
}
|