2019-11-23 20:27:39 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2013 Zynga Inc.
|
|
|
|
Copyright (c) 2013-2016 Chukong Technologies Inc.
|
|
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
|
|
|
|
2022-10-01 16:24:52 +08:00
|
|
|
https://axmolengine.github.io/
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-06-11 13:08:08 +08:00
|
|
|
#include "2d/Label.h"
|
2019-11-23 20:27:39 +08:00
|
|
|
#include <algorithm>
|
2021-12-25 10:04:45 +08:00
|
|
|
#include <stddef.h> // offsetof
|
2023-06-11 13:08:08 +08:00
|
|
|
#include "base/Types.h"
|
|
|
|
#include "2d/Font.h"
|
|
|
|
#include "2d/FontAtlasCache.h"
|
|
|
|
#include "2d/FontAtlas.h"
|
|
|
|
#include "2d/Sprite.h"
|
|
|
|
#include "2d/SpriteBatchNode.h"
|
|
|
|
#include "2d/DrawNode.h"
|
|
|
|
#include "2d/Camera.h"
|
|
|
|
#include "base/UTF8.h"
|
|
|
|
#include "base/Macros.h"
|
|
|
|
#include "platform/FileUtils.h"
|
|
|
|
#include "renderer/Renderer.h"
|
|
|
|
#include "renderer/RenderCommand.h"
|
|
|
|
#include "base/Director.h"
|
|
|
|
#include "base/EventListenerCustom.h"
|
|
|
|
#include "base/EventDispatcher.h"
|
|
|
|
#include "base/EventCustom.h"
|
|
|
|
#include "base/Utils.h"
|
|
|
|
#include "2d/FontFNT.h"
|
|
|
|
#include "renderer/Shaders.h"
|
2019-11-23 20:27:39 +08:00
|
|
|
#include "renderer/backend/ProgramState.h"
|
|
|
|
#include "renderer/backend/ProgramStateRegistry.h"
|
|
|
|
|
2022-07-11 17:50:21 +08:00
|
|
|
NS_AX_BEGIN
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
namespace
|
|
|
|
{
|
|
|
|
void updateBlend(backend::BlendDescriptor& blendDescriptor, BlendFunc blendFunc)
|
|
|
|
{
|
|
|
|
blendDescriptor.blendEnabled = true;
|
|
|
|
if (blendFunc == BlendFunc::ALPHA_NON_PREMULTIPLIED)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
blendDescriptor.sourceRGBBlendFactor = backend::BlendFactor::SRC_ALPHA;
|
|
|
|
blendDescriptor.destinationRGBBlendFactor = backend::BlendFactor::ONE_MINUS_SRC_ALPHA;
|
|
|
|
blendDescriptor.sourceAlphaBlendFactor = backend::BlendFactor::SRC_ALPHA;
|
|
|
|
blendDescriptor.destinationAlphaBlendFactor = backend::BlendFactor::ONE_MINUS_SRC_ALPHA;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
blendDescriptor.sourceRGBBlendFactor = backend::BlendFactor::ONE;
|
|
|
|
blendDescriptor.destinationRGBBlendFactor = backend::BlendFactor::ONE_MINUS_SRC_ALPHA;
|
|
|
|
blendDescriptor.sourceAlphaBlendFactor = backend::BlendFactor::ONE;
|
|
|
|
blendDescriptor.destinationAlphaBlendFactor = backend::BlendFactor::ONE_MINUS_SRC_ALPHA;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
} // namespace
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* LabelLetter used to update the quad in texture atlas without SpriteBatchNode.
|
|
|
|
*/
|
|
|
|
class LabelLetter : public Sprite
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
LabelLetter()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_textureAtlas = nullptr;
|
2019-11-23 20:27:39 +08:00
|
|
|
_letterVisible = true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
static LabelLetter* createWithTexture(Texture2D* texture, const Rect& rect, bool rotated = false)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
auto letter = new LabelLetter();
|
|
|
|
if (letter->initWithTexture(texture, rect, rotated))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
letter->Sprite::setVisible(false);
|
|
|
|
letter->autorelease();
|
|
|
|
return letter;
|
|
|
|
}
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_DELETE(letter);
|
2019-11-23 20:27:39 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
CREATE_FUNC(LabelLetter);
|
|
|
|
|
|
|
|
virtual void updateTransform() override
|
|
|
|
{
|
|
|
|
if (isDirty())
|
|
|
|
{
|
|
|
|
_transformToBatch = getNodeToParentTransform();
|
2021-12-25 10:04:45 +08:00
|
|
|
Vec2& size = _rect.size;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
float x1 = _offsetPosition.x;
|
|
|
|
float y1 = _offsetPosition.y;
|
|
|
|
float x2 = x1 + size.width;
|
|
|
|
float y2 = y1 + size.height;
|
|
|
|
|
|
|
|
// issue #17022: don't flip, again, the letter since they are flipped in sprite's code
|
2021-12-25 10:04:45 +08:00
|
|
|
// if (_flippedX) std::swap(x1, x2);
|
|
|
|
// if (_flippedY) std::swap(y1, y2);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
float x = _transformToBatch.m[12];
|
|
|
|
float y = _transformToBatch.m[13];
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
float cr = _transformToBatch.m[0];
|
|
|
|
float sr = _transformToBatch.m[1];
|
2019-11-23 20:27:39 +08:00
|
|
|
float cr2 = _transformToBatch.m[5];
|
|
|
|
float sr2 = -_transformToBatch.m[4];
|
2021-12-25 10:04:45 +08:00
|
|
|
float ax = x1 * cr - y1 * sr2 + x;
|
|
|
|
float ay = x1 * sr + y1 * cr2 + y;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
float bx = x2 * cr - y1 * sr2 + x;
|
|
|
|
float by = x2 * sr + y1 * cr2 + y;
|
|
|
|
float cx = x2 * cr - y2 * sr2 + x;
|
|
|
|
float cy = x2 * sr + y2 * cr2 + y;
|
|
|
|
float dx = x1 * cr - y2 * sr2 + x;
|
|
|
|
float dy = x1 * sr + y2 * cr2 + y;
|
|
|
|
|
|
|
|
_quad.bl.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(ax), SPRITE_RENDER_IN_SUBPIXEL(ay), _positionZ);
|
|
|
|
_quad.br.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(bx), SPRITE_RENDER_IN_SUBPIXEL(by), _positionZ);
|
|
|
|
_quad.tl.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(dx), SPRITE_RENDER_IN_SUBPIXEL(dy), _positionZ);
|
|
|
|
_quad.tr.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(cx), SPRITE_RENDER_IN_SUBPIXEL(cy), _positionZ);
|
|
|
|
|
|
|
|
if (_textureAtlas)
|
|
|
|
{
|
2023-07-09 19:00:12 +08:00
|
|
|
_textureAtlas->updateQuad(_quad, _atlasIndex);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
_recursiveDirty = false;
|
|
|
|
setDirty(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node::updateTransform();
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void updateColor() override
|
|
|
|
{
|
|
|
|
if (_textureAtlas == nullptr)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto displayedOpacity = _displayedOpacity;
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!_letterVisible)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
displayedOpacity = 0.0f;
|
|
|
|
}
|
|
|
|
Color4B color4(_displayedColor.r, _displayedColor.g, _displayedColor.b, displayedOpacity);
|
|
|
|
// special opacity for premultiplied textures
|
|
|
|
if (_opacityModifyRGB)
|
|
|
|
{
|
|
|
|
color4.r *= displayedOpacity / 255.0f;
|
|
|
|
color4.g *= displayedOpacity / 255.0f;
|
|
|
|
color4.b *= displayedOpacity / 255.0f;
|
|
|
|
}
|
|
|
|
_quad.bl.colors = color4;
|
|
|
|
_quad.br.colors = color4;
|
|
|
|
_quad.tl.colors = color4;
|
|
|
|
_quad.tr.colors = color4;
|
|
|
|
|
2023-07-09 19:00:12 +08:00
|
|
|
_textureAtlas->updateQuad(_quad, _atlasIndex);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void setVisible(bool visible) override
|
|
|
|
{
|
|
|
|
_letterVisible = visible;
|
|
|
|
updateColor();
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool isVisible() const override { return _letterVisible; }
|
|
|
|
|
|
|
|
// LabelLetter doesn't need to draw directly.
|
|
|
|
void draw(Renderer* /*renderer*/, const Mat4& /*transform*/, uint32_t /*flags*/) override {}
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
private:
|
|
|
|
bool _letterVisible;
|
|
|
|
};
|
|
|
|
|
|
|
|
Label::BatchCommand::BatchCommand()
|
|
|
|
{
|
|
|
|
textCommand.setDrawType(CustomCommand::DrawType::ELEMENT);
|
|
|
|
textCommand.setPrimitiveType(CustomCommand::PrimitiveType::TRIANGLE);
|
|
|
|
shadowCommand.setDrawType(CustomCommand::DrawType::ELEMENT);
|
|
|
|
shadowCommand.setPrimitiveType(CustomCommand::PrimitiveType::TRIANGLE);
|
|
|
|
outLineCommand.setDrawType(CustomCommand::DrawType::ELEMENT);
|
|
|
|
outLineCommand.setPrimitiveType(CustomCommand::PrimitiveType::TRIANGLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
Label::BatchCommand::~BatchCommand()
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE(textCommand.getPipelineDescriptor().programState);
|
|
|
|
AX_SAFE_RELEASE(shadowCommand.getPipelineDescriptor().programState);
|
|
|
|
AX_SAFE_RELEASE(outLineCommand.getPipelineDescriptor().programState);
|
2020-08-19 11:46:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Label::BatchCommand::setProgramState(backend::ProgramState* programState)
|
|
|
|
{
|
|
|
|
assert(programState);
|
|
|
|
|
|
|
|
auto& programStateText = textCommand.getPipelineDescriptor().programState;
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE(programStateText);
|
2020-08-19 11:46:13 +08:00
|
|
|
programStateText = programState->clone();
|
|
|
|
|
|
|
|
auto& programStateShadow = shadowCommand.getPipelineDescriptor().programState;
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE(programStateShadow);
|
2020-08-19 11:46:13 +08:00
|
|
|
programStateShadow = programState->clone();
|
|
|
|
|
|
|
|
auto& programStateOutline = outLineCommand.getPipelineDescriptor().programState;
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE(programStateOutline);
|
2020-08-19 11:46:13 +08:00
|
|
|
programStateOutline = programState->clone();
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
std::array<CustomCommand*, 3> Label::BatchCommand::getCommandArray()
|
|
|
|
{
|
2020-08-19 12:10:29 +08:00
|
|
|
return std::array<CustomCommand*, 3>{&textCommand, &shadowCommand, &outLineCommand};
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Label* Label::create()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto ret = new Label;
|
2021-12-08 00:11:53 +08:00
|
|
|
ret->autorelease();
|
2019-11-23 20:27:39 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
Label* Label::createWithSystemFont(std::string_view text,
|
|
|
|
std::string_view font,
|
2021-12-25 10:04:45 +08:00
|
|
|
float fontSize,
|
|
|
|
const Vec2& dimensions /* = Vec2::ZERO */,
|
|
|
|
TextHAlignment hAlignment /* = TextHAlignment::LEFT */,
|
|
|
|
TextVAlignment vAlignment /* = TextVAlignment::TOP */)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto ret = new Label(hAlignment, vAlignment);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
ret->setSystemFontName(font);
|
|
|
|
ret->setSystemFontSize(fontSize);
|
|
|
|
ret->setDimensions(dimensions.width, dimensions.height);
|
|
|
|
ret->setString(text);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
ret->autorelease();
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
return ret;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
Label* Label::createWithTTF(std::string_view text,
|
|
|
|
std::string_view fontFile,
|
2021-12-25 10:04:45 +08:00
|
|
|
float fontSize,
|
|
|
|
const Vec2& dimensions /* = Vec2::ZERO */,
|
|
|
|
TextHAlignment hAlignment /* = TextHAlignment::LEFT */,
|
|
|
|
TextVAlignment vAlignment /* = TextVAlignment::TOP */)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto ret = new Label(hAlignment, vAlignment);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
if (ret->initWithTTF(text, fontFile, fontSize, dimensions, hAlignment, vAlignment))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
ret->autorelease();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_DELETE(ret);
|
2019-11-23 20:27:39 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
Label* Label::createWithTTF(const TTFConfig& ttfConfig,
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string_view text,
|
2021-12-25 10:04:45 +08:00
|
|
|
TextHAlignment hAlignment /* = TextHAlignment::CENTER */,
|
|
|
|
int maxLineWidth /* = 0 */)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
auto ret = new Label(hAlignment);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
if (ret->initWithTTF(ttfConfig, text, hAlignment, maxLineWidth))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
ret->autorelease();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_DELETE(ret);
|
2019-11-23 20:27:39 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
Label* Label::createWithBMFont(std::string_view bmfontPath,
|
|
|
|
std::string_view text,
|
2021-12-25 10:04:45 +08:00
|
|
|
const TextHAlignment& hAlignment,
|
|
|
|
int maxLineWidth)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
auto ret = new Label(hAlignment);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
if (ret->setBMFontFilePath(bmfontPath))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
ret->setMaxLineWidth(maxLineWidth);
|
|
|
|
ret->setString(text);
|
|
|
|
ret->autorelease();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2020-01-06 09:35:52 +08:00
|
|
|
|
|
|
|
delete ret;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
Label* Label::createWithBMFont(std::string_view bmfontPath,
|
|
|
|
std::string_view text,
|
2021-12-25 10:04:45 +08:00
|
|
|
const TextHAlignment& hAlignment,
|
|
|
|
int maxLineWidth,
|
|
|
|
const Rect& imageRect,
|
|
|
|
bool imageRotated)
|
2020-01-06 09:35:52 +08:00
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
auto ret = new Label(hAlignment);
|
2020-01-06 09:35:52 +08:00
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
if (ret->setBMFontFilePath(bmfontPath, imageRect, imageRotated))
|
2020-01-06 09:35:52 +08:00
|
|
|
{
|
|
|
|
ret->setMaxLineWidth(maxLineWidth);
|
|
|
|
ret->setString(text);
|
|
|
|
ret->autorelease();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
delete ret;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
Label* Label::createWithBMFont(std::string_view bmfontPath,
|
|
|
|
std::string_view text,
|
2021-12-25 10:04:45 +08:00
|
|
|
const TextHAlignment& hAlignment,
|
|
|
|
int maxLineWidth,
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string_view subTextureKey)
|
2020-01-06 09:35:52 +08:00
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
auto ret = new Label(hAlignment);
|
2020-01-06 09:35:52 +08:00
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
if (ret->setBMFontFilePath(bmfontPath, subTextureKey))
|
2020-01-06 09:35:52 +08:00
|
|
|
{
|
|
|
|
ret->setMaxLineWidth(maxLineWidth);
|
|
|
|
ret->setString(text);
|
|
|
|
ret->autorelease();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
delete ret;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
Label* Label::createWithBMFont(std::string_view bmfontPath,
|
|
|
|
std::string_view text,
|
2021-12-25 10:04:45 +08:00
|
|
|
const TextHAlignment& hAlignment,
|
|
|
|
int maxLineWidth,
|
|
|
|
const Vec2& imageOffset)
|
2020-01-06 09:35:52 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
return createWithBMFont(bmfontPath, text, hAlignment, maxLineWidth, Rect(imageOffset.x, imageOffset.y, 0, 0),
|
|
|
|
false);
|
2020-01-06 09:35:52 +08:00
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
Label* Label::createWithCharMap(std::string_view plistFile)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
auto ret = new Label();
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
if (ret->setCharMap(plistFile))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
ret->autorelease();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
delete ret;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Label* Label::createWithCharMap(Texture2D* texture, int itemWidth, int itemHeight, int startCharMap)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
auto ret = new Label();
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (ret->setCharMap(texture, itemWidth, itemHeight, startCharMap))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
ret->autorelease();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
delete ret;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
Label* Label::createWithCharMap(std::string_view charMapFile, int itemWidth, int itemHeight, int startCharMap)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
auto ret = new Label();
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (ret->setCharMap(charMapFile, itemWidth, itemHeight, startCharMap))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
ret->autorelease();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
delete ret;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Label::setCharMap(std::string_view plistFile)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
auto newAtlas = FontAtlasCache::getFontAtlasCharMap(plistFile);
|
|
|
|
|
|
|
|
if (!newAtlas)
|
|
|
|
{
|
|
|
|
reset();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
_currentLabelType = LabelType::CHARMAP;
|
|
|
|
setFontAtlas(newAtlas);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Label::initWithTTF(std::string_view text,
|
|
|
|
std::string_view fontFilePath,
|
2021-12-25 10:04:45 +08:00
|
|
|
float fontSize,
|
2021-10-23 23:27:14 +08:00
|
|
|
const Vec2& dimensions,
|
2021-12-25 10:04:45 +08:00
|
|
|
TextHAlignment /*hAlignment*/,
|
|
|
|
TextVAlignment /*vAlignment*/)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (FileUtils::getInstance()->isFileExist(fontFilePath))
|
|
|
|
{
|
|
|
|
TTFConfig ttfConfig(fontFilePath, fontSize, GlyphCollection::DYNAMIC);
|
|
|
|
if (setTTFConfig(ttfConfig))
|
|
|
|
{
|
|
|
|
setDimensions(dimensions.width, dimensions.height);
|
|
|
|
setString(text);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Label::initWithTTF(const TTFConfig& ttfConfig,
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string_view text,
|
2021-12-25 10:04:45 +08:00
|
|
|
TextHAlignment /*hAlignment*/,
|
|
|
|
int maxLineWidth)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (FileUtils::getInstance()->isFileExist(ttfConfig.fontFilePath) && setTTFConfig(ttfConfig))
|
|
|
|
{
|
|
|
|
setMaxLineWidth(maxLineWidth);
|
|
|
|
setString(text);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Label::setCharMap(Texture2D* texture, int itemWidth, int itemHeight, int startCharMap)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto newAtlas = FontAtlasCache::getFontAtlasCharMap(texture, itemWidth, itemHeight, startCharMap);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (!newAtlas)
|
|
|
|
{
|
|
|
|
reset();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
_currentLabelType = LabelType::CHARMAP;
|
|
|
|
setFontAtlas(newAtlas);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Label::setCharMap(std::string_view charMapFile, int itemWidth, int itemHeight, int startCharMap)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto newAtlas = FontAtlasCache::getFontAtlasCharMap(charMapFile, itemWidth, itemHeight, startCharMap);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (!newAtlas)
|
|
|
|
{
|
|
|
|
reset();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
_currentLabelType = LabelType::CHARMAP;
|
|
|
|
setFontAtlas(newAtlas);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
Label::Label(TextHAlignment hAlignment /* = TextHAlignment::LEFT */,
|
2019-11-23 20:27:39 +08:00
|
|
|
TextVAlignment vAlignment /* = TextVAlignment::TOP */)
|
2021-12-25 10:04:45 +08:00
|
|
|
: _textSprite(nullptr)
|
|
|
|
, _shadowNode(nullptr)
|
|
|
|
, _fontAtlas(nullptr)
|
|
|
|
, _reusedLetter(nullptr)
|
|
|
|
, _horizontalKernings(nullptr)
|
|
|
|
, _boldEnabled(false)
|
|
|
|
, _underlineNode(nullptr)
|
|
|
|
, _strikethroughEnabled(false)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
setAnchorPoint(Vec2::ANCHOR_MIDDLE);
|
|
|
|
reset();
|
|
|
|
_hAlignment = hAlignment;
|
|
|
|
_vAlignment = vAlignment;
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
#if AX_LABEL_DEBUG_DRAW
|
2019-11-23 20:27:39 +08:00
|
|
|
_debugDrawNode = DrawNode::create();
|
|
|
|
addChild(_debugDrawNode);
|
|
|
|
#endif
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_purgeTextureListener = EventListenerCustom::create(FontAtlas::CMD_PURGE_FONTATLAS, [this](EventCustom* event) {
|
2019-11-23 20:27:39 +08:00
|
|
|
if (_fontAtlas && _currentLabelType == LabelType::TTF && event->getUserData() == _fontAtlas)
|
|
|
|
{
|
|
|
|
for (auto&& it : _letters)
|
|
|
|
{
|
|
|
|
it.second->setTexture(nullptr);
|
|
|
|
}
|
|
|
|
_batchNodes.clear();
|
|
|
|
_batchCommands.clear();
|
|
|
|
|
|
|
|
if (_fontAtlas)
|
|
|
|
{
|
|
|
|
FontAtlasCache::releaseFontAtlas(_fontAtlas);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
_eventDispatcher->addEventListenerWithFixedPriority(_purgeTextureListener, 1);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
_resetTextureListener = EventListenerCustom::create(FontAtlas::CMD_RESET_FONTATLAS, [this](EventCustom* event) {
|
2019-11-23 20:27:39 +08:00
|
|
|
if (_fontAtlas && _currentLabelType == LabelType::TTF && event->getUserData() == _fontAtlas)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_fontAtlas = nullptr;
|
2019-11-23 20:27:39 +08:00
|
|
|
auto lineHeight = _lineHeight;
|
|
|
|
this->setTTFConfig(_fontConfig);
|
|
|
|
if (_currentLabelType != LabelType::STRING_TEXTURE)
|
|
|
|
{
|
|
|
|
setLineHeight(lineHeight);
|
|
|
|
}
|
|
|
|
for (auto&& it : _letters)
|
|
|
|
{
|
|
|
|
getLetter(it.first);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
_eventDispatcher->addEventListenerWithFixedPriority(_resetTextureListener, 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
Label::~Label()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
delete[] _horizontalKernings;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (_fontAtlas)
|
|
|
|
{
|
|
|
|
Node::removeAllChildrenWithCleanup(true);
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE_NULL(_reusedLetter);
|
2019-11-23 20:27:39 +08:00
|
|
|
_batchNodes.clear();
|
2021-10-28 21:05:52 +08:00
|
|
|
FontAtlasCache::releaseFontAtlas(_fontAtlas);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
_batchCommands.clear();
|
|
|
|
_eventDispatcher->removeEventListener(_purgeTextureListener);
|
|
|
|
_eventDispatcher->removeEventListener(_resetTextureListener);
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE_NULL(_textSprite);
|
|
|
|
AX_SAFE_RELEASE_NULL(_shadowNode);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Label::reset()
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE_NULL(_textSprite);
|
|
|
|
AX_SAFE_RELEASE_NULL(_shadowNode);
|
2019-11-23 20:27:39 +08:00
|
|
|
Node::removeAllChildrenWithCleanup(true);
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE_NULL(_reusedLetter);
|
2019-11-23 20:27:39 +08:00
|
|
|
_letters.clear();
|
|
|
|
_batchNodes.clear();
|
|
|
|
_batchCommands.clear();
|
|
|
|
_lettersInfo.clear();
|
|
|
|
if (_fontAtlas)
|
|
|
|
{
|
2021-10-28 21:05:52 +08:00
|
|
|
FontAtlasCache::releaseFontAtlas(_fontAtlas);
|
2019-11-23 20:27:39 +08:00
|
|
|
_fontAtlas = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
_currentLabelType = LabelType::STRING_TEXTURE;
|
2021-12-25 10:04:45 +08:00
|
|
|
_currLabelEffect = LabelEffect::NORMAL;
|
|
|
|
_contentDirty = false;
|
|
|
|
_numberOfLines = 0;
|
|
|
|
_lengthOfString = 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
_utf32Text.clear();
|
|
|
|
_utf8Text.clear();
|
|
|
|
|
|
|
|
TTFConfig temp;
|
2021-12-25 10:04:45 +08:00
|
|
|
_fontConfig = temp;
|
2019-11-23 20:27:39 +08:00
|
|
|
_outlineSize = 0.f;
|
2020-01-06 09:35:52 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_bmFontPath = "";
|
2020-01-06 09:35:52 +08:00
|
|
|
_bmSubTextureKey = "";
|
2021-12-25 10:04:45 +08:00
|
|
|
_bmRect = Rect::ZERO;
|
|
|
|
_bmRotated = false;
|
2020-01-06 09:35:52 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
_systemFontDirty = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
_systemFont = "Helvetica";
|
2022-07-16 10:43:05 +08:00
|
|
|
_systemFontSize = AX_DEFAULT_FONT_LABEL_SIZE;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (_horizontalKernings)
|
|
|
|
{
|
|
|
|
delete[] _horizontalKernings;
|
|
|
|
_horizontalKernings = nullptr;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
_additionalKerning = 0.f;
|
|
|
|
_lineHeight = 0.f;
|
|
|
|
_lineSpacing = 0.f;
|
|
|
|
_maxLineWidth = 0.f;
|
|
|
|
_labelDimensions.width = 0.f;
|
2019-11-23 20:27:39 +08:00
|
|
|
_labelDimensions.height = 0.f;
|
2021-12-25 10:04:45 +08:00
|
|
|
_labelWidth = 0.f;
|
|
|
|
_labelHeight = 0.f;
|
2019-11-23 20:27:39 +08:00
|
|
|
_lineBreakWithoutSpaces = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
_hAlignment = TextHAlignment::LEFT;
|
|
|
|
_vAlignment = TextVAlignment::TOP;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_effectColorF = Color4F::BLACK;
|
2021-12-25 10:04:45 +08:00
|
|
|
_textColor = Color4B::WHITE;
|
|
|
|
_textColorF = Color4F::WHITE;
|
2019-11-23 20:27:39 +08:00
|
|
|
setColor(Color3B::WHITE);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_shadowDirty = false;
|
|
|
|
_shadowEnabled = false;
|
2019-11-23 20:27:39 +08:00
|
|
|
_shadowBlurRadius = 0.f;
|
|
|
|
|
|
|
|
_uniformEffectColor = -1;
|
2021-12-25 10:04:45 +08:00
|
|
|
_uniformEffectType = -1;
|
|
|
|
_uniformTextColor = -1;
|
|
|
|
|
|
|
|
_useDistanceField = false;
|
|
|
|
_useA8Shader = false;
|
|
|
|
_clipEnabled = false;
|
|
|
|
_blendFuncDirty = false;
|
|
|
|
_blendFunc = BlendFunc::ALPHA_PREMULTIPLIED;
|
2019-11-23 20:27:39 +08:00
|
|
|
_isOpacityModifyRGB = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
_insideBounds = true;
|
|
|
|
_enableWrap = true;
|
|
|
|
_bmFontSize = -1;
|
|
|
|
_bmfontScale = 1.0f;
|
|
|
|
_overflow = Overflow::NONE;
|
|
|
|
_originalFontSize = 0.0f;
|
|
|
|
_boldEnabled = false;
|
2019-11-23 20:27:39 +08:00
|
|
|
if (_underlineNode)
|
|
|
|
{
|
|
|
|
removeChild(_underlineNode);
|
|
|
|
_underlineNode = nullptr;
|
|
|
|
}
|
|
|
|
_strikethroughEnabled = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
setRotationSkewX(0); // reverse italics
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// ETC1 ALPHA supports, for LabelType::BMFONT & LabelType::CHARMAP
|
|
|
|
static Texture2D* _getTexture(Label* label)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto fontAtlas = label->getFontAtlas();
|
2019-11-23 20:27:39 +08:00
|
|
|
Texture2D* texture = nullptr;
|
2021-12-25 10:04:45 +08:00
|
|
|
if (fontAtlas != nullptr)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
auto textures = fontAtlas->getTextures();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!textures.empty())
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
texture = textures.begin()->second;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return texture;
|
|
|
|
}
|
|
|
|
|
2022-10-20 20:19:56 +08:00
|
|
|
void Label::setVertexLayout()
|
|
|
|
{
|
2023-09-01 10:31:34 +08:00
|
|
|
_programState->validateSharedVertexLayout(VertexLayoutHelper::setupSprite);
|
2022-10-20 20:19:56 +08:00
|
|
|
}
|
|
|
|
|
2023-09-01 10:31:34 +08:00
|
|
|
bool Label::setProgramState(backend::ProgramState* programState, bool needsRetain)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2023-09-01 10:31:34 +08:00
|
|
|
if (Node::setProgramState(programState, needsRetain))
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
2020-09-09 13:03:31 +08:00
|
|
|
updateUniformLocations();
|
2022-07-21 19:19:08 +08:00
|
|
|
for (auto&& batch : _batchCommands)
|
2020-09-09 13:03:31 +08:00
|
|
|
{
|
|
|
|
updateBatchCommand(batch);
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-10-20 20:19:56 +08:00
|
|
|
setVertexLayout();
|
|
|
|
|
2023-09-01 10:31:34 +08:00
|
|
|
auto& quadPipeline = _quadCommand.getPipelineDescriptor();
|
2020-09-09 13:03:31 +08:00
|
|
|
quadPipeline.programState = _programState;
|
2023-09-01 10:31:34 +08:00
|
|
|
|
2020-09-09 13:03:31 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateShaderProgram()
|
|
|
|
{
|
2020-10-16 16:23:14 +08:00
|
|
|
uint32_t programType = backend::ProgramType::POSITION_TEXTURE_COLOR;
|
2019-11-23 20:27:39 +08:00
|
|
|
if (_currentLabelType == LabelType::BMFONT || _currentLabelType == LabelType::CHARMAP)
|
|
|
|
{
|
|
|
|
auto texture = _getTexture(this);
|
2021-12-25 10:04:45 +08:00
|
|
|
if (texture)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
programType =
|
|
|
|
backend::ProgramStateRegistry::getInstance()->getProgramType(programType, texture->getSamplerFlags());
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
switch (_currLabelEffect)
|
|
|
|
{
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::NORMAL:
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_useDistanceField)
|
2023-09-01 10:31:34 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
programType = backend::ProgramType::LABEL_DISTANCE_NORMAL;
|
2023-09-01 10:31:34 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else if (_useA8Shader)
|
2023-09-01 10:31:34 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
programType = backend::ProgramType::LABEL_NORMAL;
|
2023-09-01 10:31:34 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
auto texture = _getTexture(this);
|
|
|
|
if (texture)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
programType = backend::ProgramStateRegistry::getInstance()->getProgramType(
|
|
|
|
programType, texture->getSamplerFlags());
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
break;
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::OUTLINE:
|
2023-09-01 10:31:34 +08:00
|
|
|
{
|
|
|
|
programType = backend::ProgramType::LABLE_OUTLINE;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::GLOW:
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_useDistanceField)
|
2023-09-01 10:31:34 +08:00
|
|
|
{
|
|
|
|
programType = backend::ProgramType::LABLE_DISTANCEFIELD_GLOW;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-09-01 10:31:34 +08:00
|
|
|
auto* program = backend::Program::getBuiltinProgram(programType);
|
|
|
|
setProgramState(new backend::ProgramState(program), false);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
updateUniformLocations();
|
|
|
|
|
2022-07-21 19:19:08 +08:00
|
|
|
for (auto&& batch : _batchCommands)
|
2023-09-01 10:31:34 +08:00
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
updateBatchCommand(batch);
|
2023-09-01 10:31:34 +08:00
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2023-09-01 10:31:34 +08:00
|
|
|
auto& quadPipeline = _quadCommand.getPipelineDescriptor();
|
2019-11-23 20:27:39 +08:00
|
|
|
quadPipeline.programState = _programState;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void Label::updateBatchCommand(Label::BatchCommand& batch)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(_programState, "programState should be set!");
|
2020-08-19 11:46:13 +08:00
|
|
|
batch.setProgramState(_programState);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateUniformLocations()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_mvpMatrixLocation = _programState->getUniformLocation(backend::Uniform::MVP_MATRIX);
|
|
|
|
_textureLocation = _programState->getUniformLocation(backend::Uniform::TEXTURE);
|
|
|
|
_textColorLocation = _programState->getUniformLocation(backend::Uniform::TEXT_COLOR);
|
|
|
|
_effectColorLocation = _programState->getUniformLocation(backend::Uniform::EFFECT_COLOR);
|
|
|
|
_effectTypeLocation = _programState->getUniformLocation(backend::Uniform::EFFECT_TYPE);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void Label::setFontAtlas(FontAtlas* atlas, bool distanceFieldEnabled /* = false */, bool useA8Shader /* = false */)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (atlas)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
_systemFontDirty = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (atlas == _fontAtlas)
|
|
|
|
return;
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RETAIN(atlas);
|
2019-11-23 20:27:39 +08:00
|
|
|
if (_fontAtlas)
|
|
|
|
{
|
|
|
|
_batchNodes.clear();
|
2021-10-28 21:05:52 +08:00
|
|
|
FontAtlasCache::releaseFontAtlas(_fontAtlas);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
_fontAtlas = atlas;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (_reusedLetter == nullptr)
|
|
|
|
{
|
|
|
|
_reusedLetter = Sprite::create();
|
2021-12-25 10:04:45 +08:00
|
|
|
_reusedLetter->setOpacityModifyRGB(_isOpacityModifyRGB);
|
2019-11-23 20:27:39 +08:00
|
|
|
_reusedLetter->retain();
|
|
|
|
_reusedLetter->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_fontAtlas)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_lineHeight = _fontAtlas->getLineHeight();
|
|
|
|
_contentDirty = true;
|
2019-11-23 20:27:39 +08:00
|
|
|
_systemFontDirty = false;
|
|
|
|
}
|
|
|
|
_useDistanceField = distanceFieldEnabled;
|
2021-12-25 10:04:45 +08:00
|
|
|
_useA8Shader = useA8Shader;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (_currentLabelType != LabelType::TTF)
|
|
|
|
{
|
|
|
|
_currLabelEffect = LabelEffect::NORMAL;
|
|
|
|
updateShaderProgram();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Label::setTTFConfig(const TTFConfig& ttfConfig)
|
|
|
|
{
|
|
|
|
_originalFontSize = ttfConfig.fontSize;
|
|
|
|
return setTTFConfigInternal(ttfConfig);
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Label::setBMFontFilePath(std::string_view bmfontFilePath, float fontSize)
|
2020-01-06 09:35:52 +08:00
|
|
|
{
|
|
|
|
FontAtlas* newAtlas = FontAtlasCache::getFontAtlasFNT(bmfontFilePath);
|
|
|
|
|
|
|
|
if (!newAtlas)
|
|
|
|
{
|
|
|
|
reset();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// assign the default fontSize
|
|
|
|
if (std::abs(fontSize) < FLT_EPSILON)
|
|
|
|
{
|
2020-01-06 09:35:52 +08:00
|
|
|
FontFNT* bmFont = (FontFNT*)newAtlas->getFont();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (bmFont)
|
|
|
|
{
|
2020-01-06 09:35:52 +08:00
|
|
|
float originalFontSize = bmFont->getOriginalFontSize();
|
2022-07-16 10:43:05 +08:00
|
|
|
_bmFontSize = originalFontSize / AX_CONTENT_SCALE_FACTOR();
|
2020-01-06 09:35:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (fontSize > 0.0f)
|
|
|
|
{
|
2020-01-06 09:35:52 +08:00
|
|
|
_bmFontSize = fontSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
_bmFontPath = bmfontFilePath;
|
|
|
|
|
|
|
|
_currentLabelType = LabelType::BMFONT;
|
|
|
|
setFontAtlas(newAtlas);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Label::setBMFontFilePath(std::string_view bmfontFilePath, const Rect& imageRect, bool imageRotated, float fontSize)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
FontAtlas* newAtlas = FontAtlasCache::getFontAtlasFNT(bmfontFilePath, imageRect, imageRotated);
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (!newAtlas)
|
|
|
|
{
|
|
|
|
reset();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// assign the default fontSize
|
|
|
|
if (std::abs(fontSize) < FLT_EPSILON)
|
|
|
|
{
|
|
|
|
FontFNT* bmFont = (FontFNT*)newAtlas->getFont();
|
|
|
|
if (bmFont)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
float originalFontSize = bmFont->getOriginalFontSize();
|
2022-07-16 10:43:05 +08:00
|
|
|
_bmFontSize = originalFontSize / AX_CONTENT_SCALE_FACTOR();
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (fontSize > 0.0f)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
_bmFontSize = fontSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
_bmFontPath = bmfontFilePath;
|
2021-12-25 10:04:45 +08:00
|
|
|
_bmRect = imageRect;
|
|
|
|
_bmRotated = imageRotated;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_currentLabelType = LabelType::BMFONT;
|
|
|
|
setFontAtlas(newAtlas);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Label::setBMFontFilePath(std::string_view bmfontFilePath, std::string_view subTextureKey, float fontSize)
|
2020-01-06 09:35:52 +08:00
|
|
|
{
|
|
|
|
FontAtlas* newAtlas = FontAtlasCache::getFontAtlasFNT(bmfontFilePath, subTextureKey);
|
|
|
|
|
|
|
|
if (!newAtlas)
|
|
|
|
{
|
|
|
|
reset();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// assign the default fontSize
|
|
|
|
if (std::abs(fontSize) < FLT_EPSILON)
|
|
|
|
{
|
2020-01-06 09:35:52 +08:00
|
|
|
FontFNT* bmFont = (FontFNT*)newAtlas->getFont();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (bmFont)
|
|
|
|
{
|
2020-01-06 09:35:52 +08:00
|
|
|
float originalFontSize = bmFont->getOriginalFontSize();
|
2022-07-16 10:43:05 +08:00
|
|
|
_bmFontSize = originalFontSize / AX_CONTENT_SCALE_FACTOR();
|
2020-01-06 09:35:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (fontSize > 0.0f)
|
|
|
|
{
|
2020-01-06 09:35:52 +08:00
|
|
|
_bmFontSize = fontSize;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_bmFontPath = bmfontFilePath;
|
2020-01-06 09:35:52 +08:00
|
|
|
_bmSubTextureKey = subTextureKey;
|
|
|
|
|
|
|
|
_currentLabelType = LabelType::BMFONT;
|
|
|
|
setFontAtlas(newAtlas);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool Label::setBMFontFilePath(std::string_view bmfontFilePath, const Vec2& imageOffset, float fontSize)
|
2020-01-06 09:35:52 +08:00
|
|
|
{
|
|
|
|
return setBMFontFilePath(bmfontFilePath, Rect(imageOffset.x, imageOffset.y, 0, 0), false);
|
|
|
|
}
|
|
|
|
|
2021-12-01 03:35:34 +08:00
|
|
|
void Label::setString(std::string_view text)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (text.compare(_utf8Text))
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_utf8Text = text;
|
2019-11-23 20:27:39 +08:00
|
|
|
_contentDirty = true;
|
|
|
|
|
|
|
|
std::u32string utf32String;
|
|
|
|
if (StringUtils::UTF8ToUTF32(_utf8Text, utf32String))
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_utf32Text = utf32String;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void Label::setAlignment(TextHAlignment hAlignment, TextVAlignment vAlignment)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (hAlignment != _hAlignment || vAlignment != _vAlignment)
|
|
|
|
{
|
|
|
|
_hAlignment = hAlignment;
|
|
|
|
_vAlignment = vAlignment;
|
|
|
|
|
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setMaxLineWidth(float maxLineWidth)
|
|
|
|
{
|
|
|
|
if (_labelWidth == 0 && _maxLineWidth != maxLineWidth)
|
|
|
|
{
|
|
|
|
_maxLineWidth = maxLineWidth;
|
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setDimensions(float width, float height)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_overflow == Overflow::RESIZE_HEIGHT)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
height = 0;
|
|
|
|
}
|
|
|
|
if (height != _labelHeight || width != _labelWidth)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_labelWidth = width;
|
|
|
|
_labelHeight = height;
|
|
|
|
_labelDimensions.width = width;
|
2019-11-23 20:27:39 +08:00
|
|
|
_labelDimensions.height = height;
|
|
|
|
|
|
|
|
_maxLineWidth = width;
|
|
|
|
_contentDirty = true;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_overflow == Overflow::SHRINK)
|
|
|
|
{
|
|
|
|
if (_originalFontSize > 0)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
this->restoreFontSize();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::restoreFontSize()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_currentLabelType == LabelType::TTF)
|
|
|
|
{
|
|
|
|
auto ttfConfig = this->getTTFConfig();
|
2019-11-23 20:27:39 +08:00
|
|
|
ttfConfig.fontSize = _originalFontSize;
|
|
|
|
this->setTTFConfigInternal(ttfConfig);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (_currentLabelType == LabelType::BMFONT)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
this->setBMFontSizeInternal(_originalFontSize);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (_currentLabelType == LabelType::STRING_TEXTURE)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
this->setSystemFontSize(_originalFontSize);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setLineBreakWithoutSpace(bool breakWithoutSpace)
|
|
|
|
{
|
|
|
|
if (breakWithoutSpace != _lineBreakWithoutSpaces)
|
|
|
|
{
|
|
|
|
_lineBreakWithoutSpaces = breakWithoutSpace;
|
2021-12-25 10:04:45 +08:00
|
|
|
_contentDirty = true;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateLabelLetters()
|
|
|
|
{
|
|
|
|
if (!_letters.empty())
|
|
|
|
{
|
|
|
|
Rect uvRect;
|
|
|
|
LabelLetter* letterSprite;
|
|
|
|
int letterIndex;
|
|
|
|
|
|
|
|
for (auto it = _letters.begin(); it != _letters.end();)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
letterIndex = it->first;
|
2019-11-23 20:27:39 +08:00
|
|
|
letterSprite = (LabelLetter*)it->second;
|
|
|
|
|
|
|
|
if (letterIndex >= _lengthOfString)
|
|
|
|
{
|
|
|
|
Node::removeChild(letterSprite, true);
|
|
|
|
it = _letters.erase(it);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
auto& letterInfo = _lettersInfo[letterIndex];
|
|
|
|
if (letterInfo.valid)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto& letterDef = _fontAtlas->_letterDefinitions[letterInfo.utf32Char];
|
2019-11-23 20:27:39 +08:00
|
|
|
uvRect.size.height = letterDef.height;
|
2021-12-25 10:04:45 +08:00
|
|
|
uvRect.size.width = letterDef.width;
|
|
|
|
uvRect.origin.x = letterDef.U;
|
|
|
|
uvRect.origin.y = letterDef.V;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
auto batchNode = _batchNodes.at(letterDef.textureID);
|
|
|
|
letterSprite->setTextureAtlas(batchNode->getTextureAtlas());
|
|
|
|
letterSprite->setTexture(_fontAtlas->getTexture(letterDef.textureID));
|
|
|
|
if (letterDef.width <= 0.f || letterDef.height <= 0.f)
|
|
|
|
{
|
|
|
|
letterSprite->setTextureAtlas(nullptr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-01-06 09:35:52 +08:00
|
|
|
letterSprite->setTextureRect(uvRect, letterDef.rotated, uvRect.size);
|
2019-11-23 20:27:39 +08:00
|
|
|
letterSprite->setTextureAtlas(_batchNodes.at(letterDef.textureID)->getTextureAtlas());
|
|
|
|
letterSprite->setAtlasIndex(_lettersInfo[letterIndex].atlasIndex);
|
|
|
|
}
|
|
|
|
|
|
|
|
auto px = letterInfo.positionX + letterDef.width / 2 + _linesOffsetX[letterInfo.lineIndex];
|
|
|
|
auto py = letterInfo.positionY - letterDef.height / 2 + _letterOffsetY;
|
|
|
|
letterSprite->setPosition(px, py);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
letterSprite->setTextureAtlas(nullptr);
|
|
|
|
}
|
|
|
|
this->updateLetterSpriteScale(letterSprite);
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Label::alignText()
|
|
|
|
{
|
|
|
|
if (_fontAtlas == nullptr || _utf32Text.empty())
|
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
setContentSize(Vec2::ZERO);
|
2019-11-23 20:27:39 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ret = true;
|
2021-12-25 10:04:45 +08:00
|
|
|
do
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
_fontAtlas->prepareLetterDefinitions(_utf32Text);
|
|
|
|
auto& textures = _fontAtlas->getTextures();
|
2021-12-25 10:04:45 +08:00
|
|
|
auto size = textures.size();
|
2019-11-23 20:27:39 +08:00
|
|
|
if (size > static_cast<size_t>(_batchNodes.size()))
|
|
|
|
{
|
2022-11-20 08:58:34 +08:00
|
|
|
for (auto index = static_cast<unsigned int>(_batchNodes.size()); index < size; ++index)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
auto batchNode = SpriteBatchNode::createWithTexture(textures.at(index));
|
|
|
|
if (batchNode)
|
|
|
|
{
|
|
|
|
_isOpacityModifyRGB = batchNode->getTexture()->hasPremultipliedAlpha();
|
2021-12-25 10:04:45 +08:00
|
|
|
_blendFunc = batchNode->getBlendFunc();
|
2019-11-23 20:27:39 +08:00
|
|
|
batchNode->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
|
|
|
|
batchNode->setPosition(Vec2::ZERO);
|
|
|
|
_batchNodes.pushBack(batchNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (_batchNodes.empty())
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
// optimize for one-texture-only scenario
|
|
|
|
// if multiple textures, then we should count how many chars
|
|
|
|
// are per texture
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_batchNodes.size() == 1)
|
2019-11-23 20:27:39 +08:00
|
|
|
_batchNodes.at(0)->reserveCapacity(_utf32Text.size());
|
|
|
|
|
|
|
|
_reusedLetter->setBatchNode(_batchNodes.at(0));
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
_lengthOfString = 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
_textDesiredHeight = 0.f;
|
|
|
|
_linesWidth.clear();
|
|
|
|
if (_maxLineWidth > 0.f && !_lineBreakWithoutSpaces)
|
|
|
|
{
|
|
|
|
multilineTextWrapByWord();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
multilineTextWrapByChar();
|
|
|
|
}
|
|
|
|
computeAlignmentOffset();
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_overflow == Overflow::SHRINK)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
float fontSize = this->getRenderingFontSize();
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (fontSize > 0 && isVerticalClamp())
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
this->shrinkLabelToContentSize(AX_CALLBACK_0(Label::isVerticalClamp, this));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!updateQuads())
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
ret = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_overflow == Overflow::SHRINK)
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
this->shrinkLabelToContentSize(AX_CALLBACK_0(Label::isHorizontalClamp, this));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
updateLabelLetters();
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
updateColor();
|
2021-12-25 10:04:45 +08:00
|
|
|
} while (0);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Label::computeHorizontalKernings(const std::u32string& stringToRender)
|
|
|
|
{
|
|
|
|
if (_horizontalKernings)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
delete[] _horizontalKernings;
|
2019-11-23 20:27:39 +08:00
|
|
|
_horizontalKernings = nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
int letterCount = 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
_horizontalKernings = _fontAtlas->getFont()->getHorizontalKerningForTextUTF32(stringToRender, letterCount);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!_horizontalKernings)
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
else
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Label::isHorizontalClamped(float letterPositionX, int lineIndex)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto wordWidth = this->_linesWidth[lineIndex];
|
2019-11-23 20:27:39 +08:00
|
|
|
bool letterOverClamp = (letterPositionX > _contentSize.width || letterPositionX < 0);
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!_enableWrap)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
return letterOverClamp;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
return (wordWidth > this->_contentSize.width && letterOverClamp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Label::updateQuads()
|
|
|
|
{
|
|
|
|
bool ret = true;
|
|
|
|
for (auto&& batchNode : _batchNodes)
|
|
|
|
{
|
|
|
|
batchNode->getTextureAtlas()->removeAllQuads();
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
for (int ctr = 0; ctr < _lengthOfString; ++ctr)
|
|
|
|
{
|
|
|
|
if (_lettersInfo[ctr].valid)
|
|
|
|
{
|
|
|
|
auto& letterDef = _fontAtlas->_letterDefinitions[_lettersInfo[ctr].utf32Char];
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
_reusedRect.size.height = letterDef.height;
|
|
|
|
_reusedRect.size.width = letterDef.width;
|
|
|
|
_reusedRect.origin.x = letterDef.U;
|
|
|
|
_reusedRect.origin.y = letterDef.V;
|
|
|
|
|
|
|
|
auto py = _lettersInfo[ctr].positionY + _letterOffsetY;
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_labelHeight > 0.f)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
if (py > _tailoredTopY)
|
|
|
|
{
|
|
|
|
auto clipTop = py - _tailoredTopY;
|
|
|
|
_reusedRect.origin.y += clipTop;
|
|
|
|
_reusedRect.size.height -= clipTop;
|
|
|
|
py -= clipTop;
|
|
|
|
}
|
|
|
|
if (py - letterDef.height * _bmfontScale < _tailoredBottomY)
|
|
|
|
{
|
|
|
|
_reusedRect.size.height = (py < _tailoredBottomY) ? 0.f : (py - _tailoredBottomY);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
auto lineIndex = _lettersInfo[ctr].lineIndex;
|
2021-12-25 10:04:45 +08:00
|
|
|
auto px = _lettersInfo[ctr].positionX + letterDef.width / 2 * _bmfontScale + _linesOffsetX[lineIndex];
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_labelWidth > 0.f)
|
|
|
|
{
|
|
|
|
if (this->isHorizontalClamped(px, lineIndex))
|
|
|
|
{
|
|
|
|
if (_overflow == Overflow::CLAMP)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
_reusedRect.size.width = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (_overflow == Overflow::SHRINK)
|
|
|
|
{
|
|
|
|
if (_contentSize.width > letterDef.width)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
ret = false;
|
|
|
|
break;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
_reusedRect.size.width = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_reusedRect.size.height > 0.f && _reusedRect.size.width > 0.f)
|
|
|
|
{
|
2020-01-06 09:35:52 +08:00
|
|
|
_reusedLetter->setTextureRect(_reusedRect, letterDef.rotated, _reusedRect.size);
|
2019-11-23 20:27:39 +08:00
|
|
|
float letterPositionX = _lettersInfo[ctr].positionX + _linesOffsetX[_lettersInfo[ctr].lineIndex];
|
|
|
|
_reusedLetter->setPosition(letterPositionX, py);
|
|
|
|
auto index = static_cast<int>(_batchNodes.at(letterDef.textureID)->getTextureAtlas()->getTotalQuads());
|
|
|
|
_lettersInfo[ctr].atlasIndex = index;
|
|
|
|
|
|
|
|
this->updateLetterSpriteScale(_reusedLetter);
|
|
|
|
|
|
|
|
_batchNodes.at(letterDef.textureID)->insertQuadFromSprite(_reusedLetter, index);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Label::setTTFConfigInternal(const TTFConfig& ttfConfig)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
FontAtlas* newAtlas = FontAtlasCache::getFontAtlasTTF(&ttfConfig);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (!newAtlas)
|
|
|
|
{
|
|
|
|
reset();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
_currentLabelType = LabelType::TTF;
|
2021-12-25 10:04:45 +08:00
|
|
|
setFontAtlas(newAtlas, ttfConfig.distanceFieldEnabled, true);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_fontConfig = ttfConfig;
|
|
|
|
|
|
|
|
if (_fontConfig.outlineSize > 0)
|
|
|
|
{
|
2023-09-01 10:31:34 +08:00
|
|
|
_fontConfig.distanceFieldEnabled = false;
|
|
|
|
_useDistanceField = false;
|
|
|
|
_useA8Shader = false;
|
|
|
|
_currLabelEffect = LabelEffect::OUTLINE;
|
2019-11-23 20:27:39 +08:00
|
|
|
updateShaderProgram();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_currLabelEffect = LabelEffect::NORMAL;
|
|
|
|
updateShaderProgram();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_fontConfig.italics)
|
|
|
|
this->enableItalics();
|
|
|
|
if (_fontConfig.bold)
|
|
|
|
this->enableBold();
|
|
|
|
if (_fontConfig.underline)
|
|
|
|
this->enableUnderline();
|
|
|
|
if (_fontConfig.strikethrough)
|
|
|
|
this->enableStrikethrough();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setBMFontSizeInternal(float fontSize)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_currentLabelType == LabelType::BMFONT)
|
2020-01-06 09:35:52 +08:00
|
|
|
{
|
|
|
|
if (!_bmSubTextureKey.empty())
|
|
|
|
{
|
|
|
|
this->setBMFontFilePath(_bmFontPath, _bmSubTextureKey, fontSize);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
this->setBMFontFilePath(_bmFontPath, _bmRect, _bmRotated, fontSize);
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-03 13:56:25 +08:00
|
|
|
void Label::scaleFontSize(float fontSize)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
bool shouldUpdateContent = true;
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_currentLabelType == LabelType::TTF)
|
|
|
|
{
|
|
|
|
auto ttfConfig = this->getTTFConfig();
|
2019-11-23 20:27:39 +08:00
|
|
|
ttfConfig.fontSize = fontSize;
|
|
|
|
this->setTTFConfigInternal(ttfConfig);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (_currentLabelType == LabelType::BMFONT)
|
|
|
|
{
|
|
|
|
if (std::abs(fontSize) < FLT_EPSILON)
|
|
|
|
{
|
|
|
|
fontSize = 0.1f;
|
2019-11-23 20:27:39 +08:00
|
|
|
shouldUpdateContent = false;
|
|
|
|
}
|
|
|
|
this->setBMFontSizeInternal(fontSize);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (_currentLabelType == LabelType::STRING_TEXTURE)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
this->setSystemFontSize(fontSize);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (shouldUpdateContent)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
this->updateContent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::enableGlow(const Color4B& glowColor)
|
|
|
|
{
|
|
|
|
if (_currentLabelType == LabelType::TTF)
|
|
|
|
{
|
|
|
|
if (_fontConfig.distanceFieldEnabled == false)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto config = _fontConfig;
|
|
|
|
config.outlineSize = 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
config.distanceFieldEnabled = true;
|
|
|
|
setTTFConfig(config);
|
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
_currLabelEffect = LabelEffect::GLOW;
|
2021-12-25 10:04:45 +08:00
|
|
|
_effectColorF.r = glowColor.r / 255.0f;
|
|
|
|
_effectColorF.g = glowColor.g / 255.0f;
|
|
|
|
_effectColorF.b = glowColor.b / 255.0f;
|
|
|
|
_effectColorF.a = glowColor.a / 255.0f;
|
2019-11-23 20:27:39 +08:00
|
|
|
updateShaderProgram();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void Label::enableOutline(const Color4B& outlineColor, int outlineSize /* = -1 */)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(_currentLabelType == LabelType::STRING_TEXTURE || _currentLabelType == LabelType::TTF,
|
2021-12-25 10:04:45 +08:00
|
|
|
"Only supported system font and TTF!");
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (outlineSize > 0 || _currLabelEffect == LabelEffect::OUTLINE)
|
|
|
|
{
|
|
|
|
if (_currentLabelType == LabelType::TTF)
|
|
|
|
{
|
|
|
|
_effectColorF.r = outlineColor.r / 255.0f;
|
|
|
|
_effectColorF.g = outlineColor.g / 255.0f;
|
|
|
|
_effectColorF.b = outlineColor.b / 255.0f;
|
|
|
|
_effectColorF.a = outlineColor.a / 255.0f;
|
|
|
|
|
2023-09-01 10:31:34 +08:00
|
|
|
if (outlineSize > 0 && _fontConfig.outlineSize != outlineSize)
|
|
|
|
{
|
|
|
|
_fontConfig.outlineSize = outlineSize;
|
|
|
|
setTTFConfig(_fontConfig);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (_effectColorF != outlineColor || _outlineSize != outlineSize)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_effectColorF.r = outlineColor.r / 255.f;
|
|
|
|
_effectColorF.g = outlineColor.g / 255.f;
|
|
|
|
_effectColorF.b = outlineColor.b / 255.f;
|
|
|
|
_effectColorF.a = outlineColor.a / 255.f;
|
2019-11-23 20:27:39 +08:00
|
|
|
_currLabelEffect = LabelEffect::OUTLINE;
|
2021-12-25 10:04:45 +08:00
|
|
|
_contentDirty = true;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
_outlineSize = outlineSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::enableShadow(const Color4B& shadowColor /* = Color4B::BLACK */,
|
2021-12-25 10:04:45 +08:00
|
|
|
const Vec2& offset /* = Vec2(2 ,-2)*/,
|
2019-11-23 20:27:39 +08:00
|
|
|
int /* blurRadius = 0 */)
|
|
|
|
{
|
|
|
|
_shadowEnabled = true;
|
2021-12-25 10:04:45 +08:00
|
|
|
_shadowDirty = true;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_shadowOffset.width = offset.width;
|
2019-11-23 20:27:39 +08:00
|
|
|
_shadowOffset.height = offset.height;
|
2021-12-25 10:04:45 +08:00
|
|
|
// TODO: support blur for shadow
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_shadowColor3B.r = shadowColor.r;
|
|
|
|
_shadowColor3B.g = shadowColor.g;
|
|
|
|
_shadowColor3B.b = shadowColor.b;
|
2021-12-25 10:04:45 +08:00
|
|
|
_shadowOpacity = shadowColor.a;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (!_systemFontDirty && !_contentDirty && _textSprite)
|
|
|
|
{
|
|
|
|
auto fontDef = _getFontDefinition();
|
|
|
|
if (_shadowNode)
|
|
|
|
{
|
|
|
|
if (shadowColor != _shadowColor4F)
|
|
|
|
{
|
|
|
|
_shadowNode->release();
|
|
|
|
_shadowNode = nullptr;
|
|
|
|
createShadowSpriteForSystemFont(fontDef);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_shadowNode->setPosition(_shadowOffset.width, _shadowOffset.height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
createShadowSpriteForSystemFont(fontDef);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
_shadowColor4F.r = shadowColor.r / 255.0f;
|
|
|
|
_shadowColor4F.g = shadowColor.g / 255.0f;
|
|
|
|
_shadowColor4F.b = shadowColor.b / 255.0f;
|
|
|
|
_shadowColor4F.a = shadowColor.a / 255.0f;
|
|
|
|
|
|
|
|
if (_currentLabelType == LabelType::BMFONT || _currentLabelType == LabelType::CHARMAP)
|
|
|
|
{
|
|
|
|
updateShaderProgram();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::enableItalics()
|
|
|
|
{
|
|
|
|
setRotationSkewX(12);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::enableBold()
|
|
|
|
{
|
|
|
|
if (!_boldEnabled)
|
|
|
|
{
|
|
|
|
// bold is implemented with outline
|
2021-10-23 23:27:14 +08:00
|
|
|
enableShadow(Color4B::WHITE, Vec2(0.9f, 0), 0);
|
2019-11-23 20:27:39 +08:00
|
|
|
// add one to kerning
|
2021-12-25 10:04:45 +08:00
|
|
|
setAdditionalKerning(_additionalKerning + 1);
|
2019-11-23 20:27:39 +08:00
|
|
|
_boldEnabled = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::enableUnderline()
|
|
|
|
{
|
|
|
|
// remove it, just in case to prevent adding two or more
|
|
|
|
if (!_underlineNode)
|
|
|
|
{
|
|
|
|
_underlineNode = DrawNode::create();
|
2021-06-09 12:09:01 +08:00
|
|
|
_underlineNode->setGlobalZOrder(getGlobalZOrder());
|
2019-11-23 20:27:39 +08:00
|
|
|
addChild(_underlineNode, 100000);
|
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::enableStrikethrough()
|
|
|
|
{
|
|
|
|
if (!_strikethroughEnabled)
|
|
|
|
{
|
|
|
|
enableUnderline();
|
|
|
|
_strikethroughEnabled = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::disableEffect()
|
|
|
|
{
|
|
|
|
disableEffect(LabelEffect::ALL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::disableEffect(LabelEffect effect)
|
|
|
|
{
|
|
|
|
switch (effect)
|
|
|
|
{
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::NORMAL:
|
2021-12-25 10:04:45 +08:00
|
|
|
break;
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::OUTLINE:
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_currLabelEffect == LabelEffect::OUTLINE)
|
|
|
|
{
|
|
|
|
if (_currentLabelType == LabelType::TTF)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_fontConfig.outlineSize = 0;
|
|
|
|
setTTFConfig(_fontConfig);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
_currLabelEffect = LabelEffect::NORMAL;
|
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::SHADOW:
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_shadowEnabled)
|
|
|
|
{
|
|
|
|
_shadowEnabled = false;
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE_NULL(_shadowNode);
|
2021-12-25 10:04:45 +08:00
|
|
|
updateShaderProgram();
|
|
|
|
}
|
|
|
|
break;
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::GLOW:
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_currLabelEffect == LabelEffect::GLOW)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_currLabelEffect = LabelEffect::NORMAL;
|
|
|
|
updateShaderProgram();
|
|
|
|
}
|
|
|
|
break;
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::ITALICS:
|
2021-12-25 10:04:45 +08:00
|
|
|
setRotationSkewX(0);
|
|
|
|
break;
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::BOLD:
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_boldEnabled)
|
|
|
|
{
|
|
|
|
_boldEnabled = false;
|
|
|
|
_additionalKerning -= 1;
|
2019-11-23 20:27:39 +08:00
|
|
|
disableEffect(LabelEffect::SHADOW);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
break;
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::UNDERLINE:
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_underlineNode)
|
|
|
|
{
|
|
|
|
removeChild(_underlineNode);
|
|
|
|
_underlineNode = nullptr;
|
|
|
|
}
|
|
|
|
break;
|
2022-08-08 18:02:17 +08:00
|
|
|
case ax::LabelEffect::STRIKETHROUGH:
|
2021-12-25 10:04:45 +08:00
|
|
|
_strikethroughEnabled = false;
|
|
|
|
// since it is based on underline, disable it as well
|
|
|
|
disableEffect(LabelEffect::UNDERLINE);
|
|
|
|
break;
|
|
|
|
case LabelEffect::ALL:
|
|
|
|
{
|
|
|
|
disableEffect(LabelEffect::SHADOW);
|
|
|
|
disableEffect(LabelEffect::GLOW);
|
|
|
|
disableEffect(LabelEffect::OUTLINE);
|
|
|
|
disableEffect(LabelEffect::ITALICS);
|
|
|
|
disableEffect(LabelEffect::BOLD);
|
|
|
|
disableEffect(LabelEffect::UNDERLINE);
|
|
|
|
disableEffect(LabelEffect::STRIKETHROUGH);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::createSpriteForSystemFont(const FontDefinition& fontDef)
|
|
|
|
{
|
|
|
|
_currentLabelType = LabelType::STRING_TEXTURE;
|
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
auto texture = new Texture2D;
|
2023-03-11 22:10:18 +08:00
|
|
|
texture->initWithString(_utf8Text, fontDef);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_textSprite = Sprite::createWithTexture(texture);
|
2021-12-25 10:04:45 +08:00
|
|
|
// set camera mask using label's camera mask, because _textSprite may be null when setting camera mask to label
|
2019-11-23 20:27:39 +08:00
|
|
|
_textSprite->setCameraMask(getCameraMask());
|
|
|
|
_textSprite->setGlobalZOrder(getGlobalZOrder());
|
|
|
|
_textSprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
|
|
|
|
this->setContentSize(_textSprite->getContentSize());
|
|
|
|
texture->release();
|
|
|
|
if (_blendFuncDirty)
|
|
|
|
{
|
|
|
|
_textSprite->setBlendFunc(_blendFunc);
|
|
|
|
}
|
|
|
|
|
|
|
|
_textSprite->retain();
|
|
|
|
_textSprite->updateDisplayedColor(_displayedColor);
|
|
|
|
_textSprite->updateDisplayedOpacity(_displayedOpacity);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::createShadowSpriteForSystemFont(const FontDefinition& fontDef)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!fontDef._stroke._strokeEnabled && fontDef._fontFillColor == _shadowColor3B &&
|
|
|
|
(fontDef._fontAlpha == _shadowOpacity))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
_shadowNode = Sprite::createWithTexture(_textSprite->getTexture());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
FontDefinition shadowFontDefinition = fontDef;
|
2019-11-23 20:27:39 +08:00
|
|
|
shadowFontDefinition._fontFillColor.r = _shadowColor3B.r;
|
|
|
|
shadowFontDefinition._fontFillColor.g = _shadowColor3B.g;
|
|
|
|
shadowFontDefinition._fontFillColor.b = _shadowColor3B.b;
|
2021-12-25 10:04:45 +08:00
|
|
|
shadowFontDefinition._fontAlpha = _shadowOpacity;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
shadowFontDefinition._stroke._strokeColor = shadowFontDefinition._fontFillColor;
|
|
|
|
shadowFontDefinition._stroke._strokeAlpha = shadowFontDefinition._fontAlpha;
|
|
|
|
|
2021-12-08 00:11:53 +08:00
|
|
|
auto texture = new Texture2D;
|
2023-03-11 22:10:18 +08:00
|
|
|
texture->initWithString(_utf8Text, shadowFontDefinition);
|
2019-11-23 20:27:39 +08:00
|
|
|
_shadowNode = Sprite::createWithTexture(texture);
|
|
|
|
texture->release();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_shadowNode)
|
|
|
|
{
|
|
|
|
if (_blendFuncDirty)
|
|
|
|
{
|
|
|
|
_shadowNode->setBlendFunc(_blendFunc);
|
|
|
|
}
|
|
|
|
_shadowNode->setCameraMask(getCameraMask());
|
|
|
|
_shadowNode->setGlobalZOrder(getGlobalZOrder());
|
|
|
|
_shadowNode->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
|
|
|
|
_shadowNode->setPosition(_shadowOffset.width, _shadowOffset.height);
|
|
|
|
|
|
|
|
_shadowNode->retain();
|
|
|
|
_shadowNode->updateDisplayedColor(_displayedColor);
|
|
|
|
_shadowNode->updateDisplayedOpacity(_displayedOpacity);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setCameraMask(unsigned short mask, bool applyChildren)
|
|
|
|
{
|
|
|
|
Node::setCameraMask(mask, applyChildren);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (_textSprite)
|
|
|
|
{
|
|
|
|
_textSprite->setCameraMask(mask, applyChildren);
|
|
|
|
}
|
|
|
|
if (_shadowNode)
|
|
|
|
{
|
|
|
|
_shadowNode->setCameraMask(mask, applyChildren);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateContent()
|
|
|
|
{
|
|
|
|
if (_systemFontDirty)
|
|
|
|
{
|
|
|
|
if (_fontAtlas)
|
|
|
|
{
|
|
|
|
_batchNodes.clear();
|
|
|
|
_batchCommands.clear();
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE_NULL(_reusedLetter);
|
2021-10-28 21:05:52 +08:00
|
|
|
FontAtlasCache::releaseFontAtlas(_fontAtlas);
|
2019-11-23 20:27:39 +08:00
|
|
|
_fontAtlas = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
_systemFontDirty = false;
|
|
|
|
}
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_RELEASE_NULL(_textSprite);
|
|
|
|
AX_SAFE_RELEASE_NULL(_shadowNode);
|
2019-11-23 20:27:39 +08:00
|
|
|
bool updateFinished = true;
|
|
|
|
|
|
|
|
if (_fontAtlas)
|
|
|
|
{
|
|
|
|
std::u32string utf32String;
|
|
|
|
if (StringUtils::UTF8ToUTF32(_utf8Text, utf32String))
|
|
|
|
{
|
|
|
|
_utf32Text = utf32String;
|
|
|
|
}
|
|
|
|
|
|
|
|
computeHorizontalKernings(_utf32Text);
|
|
|
|
updateFinished = alignText();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
auto fontDef = _getFontDefinition();
|
|
|
|
createSpriteForSystemFont(fontDef);
|
|
|
|
if (_shadowEnabled)
|
|
|
|
{
|
|
|
|
createShadowSpriteForSystemFont(fontDef);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_underlineNode)
|
|
|
|
{
|
|
|
|
_underlineNode->clear();
|
|
|
|
|
|
|
|
if (_numberOfLines)
|
|
|
|
{
|
|
|
|
// This is the logic for TTF fonts
|
|
|
|
const float charheight = (_textDesiredHeight / _numberOfLines);
|
2021-12-25 10:04:45 +08:00
|
|
|
_underlineNode->setLineWidth(charheight / 6);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// atlas font
|
2021-12-25 10:04:45 +08:00
|
|
|
for (int i = 0; i < _numberOfLines; ++i)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
float offsety = 0;
|
|
|
|
if (_strikethroughEnabled)
|
|
|
|
offsety += charheight / 2;
|
|
|
|
// FIXME: Might not work with different vertical alignments
|
|
|
|
float y = (_numberOfLines - i - 1) * charheight + offsety;
|
|
|
|
|
|
|
|
// Github issue #15214. Uses _displayedColor instead of _textColor for the underline.
|
|
|
|
// This is to have the same behavior of SystemFonts.
|
2021-12-25 10:04:45 +08:00
|
|
|
_underlineNode->drawLine(Vec2(_linesOffsetX[i], y), Vec2(_linesWidth[i] + _linesOffsetX[i], y),
|
|
|
|
Color4F(_displayedColor));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (_textSprite)
|
|
|
|
{
|
|
|
|
// ...and is the logic for System fonts
|
2021-12-25 10:04:45 +08:00
|
|
|
float y = 0;
|
2019-11-23 20:27:39 +08:00
|
|
|
const auto spriteSize = _textSprite->getContentSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
_underlineNode->setLineWidth(spriteSize.height / 6);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (_strikethroughEnabled)
|
2021-12-25 10:04:45 +08:00
|
|
|
// FIXME: system fonts don't report the height of the font correctly. only the size of the texture,
|
|
|
|
// which is POT
|
2019-11-23 20:27:39 +08:00
|
|
|
y += spriteSize.height / 2;
|
|
|
|
// FIXME: Might not work with different vertical alignments
|
2021-12-25 10:04:45 +08:00
|
|
|
_underlineNode->drawLine(Vec2(0.0f, y), Vec2(spriteSize.width, y),
|
|
|
|
Color4F(_textSprite->getDisplayedColor()));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (updateFinished)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
_contentDirty = false;
|
|
|
|
}
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
#if AX_LABEL_DEBUG_DRAW
|
2019-11-23 20:27:39 +08:00
|
|
|
_debugDrawNode->clear();
|
2021-12-25 10:04:45 +08:00
|
|
|
Vec2 vertices[4] = {Vec2::ZERO, Vec2(_contentSize.width, 0.0f), Vec2(_contentSize.width, _contentSize.height),
|
|
|
|
Vec2(0.0f, _contentSize.height)};
|
2019-11-23 20:27:39 +08:00
|
|
|
_debugDrawNode->drawPoly(vertices, 4, true, Color4F::WHITE);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setBMFontSize(float fontSize)
|
|
|
|
{
|
|
|
|
this->setBMFontSizeInternal(fontSize);
|
|
|
|
_originalFontSize = fontSize;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
float Label::getBMFontSize() const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return _bmFontSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateBuffer(TextureAtlas* textureAtlas, CustomCommand& customCommand)
|
|
|
|
{
|
|
|
|
if (textureAtlas->getTotalQuads() > customCommand.getVertexCapacity())
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
customCommand.createVertexBuffer((unsigned int)sizeof(V3F_C4B_T2F_Quad),
|
|
|
|
(unsigned int)textureAtlas->getTotalQuads(),
|
|
|
|
CustomCommand::BufferUsage::DYNAMIC);
|
|
|
|
customCommand.createIndexBuffer(CustomCommand::IndexFormat::U_SHORT,
|
|
|
|
(unsigned int)textureAtlas->getTotalQuads() * 6,
|
|
|
|
CustomCommand::BufferUsage::DYNAMIC);
|
|
|
|
}
|
|
|
|
customCommand.updateVertexBuffer(textureAtlas->getQuads(),
|
|
|
|
(unsigned int)(textureAtlas->getTotalQuads() * sizeof(V3F_C4B_T2F_Quad)));
|
|
|
|
customCommand.updateIndexBuffer(textureAtlas->getIndices(),
|
|
|
|
(unsigned int)(textureAtlas->getTotalQuads() * 6 * sizeof(unsigned short)));
|
2019-11-23 20:27:39 +08:00
|
|
|
customCommand.setIndexDrawInfo(0, (unsigned int)(textureAtlas->getTotalQuads() * 6));
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void Label::updateEffectUniforms(BatchCommand& batch,
|
|
|
|
TextureAtlas* textureAtlas,
|
|
|
|
Renderer* renderer,
|
|
|
|
const Mat4& transform)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
updateBuffer(textureAtlas, batch.textCommand);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto& matrixProjection = _director->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_shadowEnabled)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
updateBuffer(textureAtlas, batch.shadowCommand);
|
|
|
|
auto shadowMatrix = matrixProjection * _shadowTransform;
|
2021-12-25 10:04:45 +08:00
|
|
|
batch.shadowCommand.getPipelineDescriptor().programState->setUniform(_mvpMatrixLocation, shadowMatrix.m,
|
|
|
|
sizeof(shadowMatrix.m));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_currentLabelType == LabelType::TTF)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
switch (_currLabelEffect)
|
|
|
|
{
|
|
|
|
case LabelEffect::OUTLINE:
|
|
|
|
{
|
|
|
|
int effectType = 0;
|
|
|
|
Vec4 effectColor(_effectColorF.r, _effectColorF.g, _effectColorF.b, _effectColorF.a);
|
2023-09-01 10:31:34 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// draw shadow
|
|
|
|
if (_shadowEnabled)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
effectType = 2;
|
|
|
|
Vec4 shadowColor = Vec4(_shadowColor4F.r, _shadowColor4F.g, _shadowColor4F.b, _shadowColor4F.a);
|
|
|
|
auto* programStateShadow = batch.shadowCommand.getPipelineDescriptor().programState;
|
|
|
|
programStateShadow->setUniform(_effectColorLocation, &shadowColor, sizeof(Vec4));
|
|
|
|
programStateShadow->setUniform(_effectTypeLocation, &effectType, sizeof(effectType));
|
|
|
|
batch.shadowCommand.init(_globalZOrder);
|
|
|
|
renderer->addCommand(&batch.shadowCommand);
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2023-09-01 10:31:34 +08:00
|
|
|
// draw outline
|
2023-09-01 01:17:49 +08:00
|
|
|
{
|
2023-09-01 10:31:34 +08:00
|
|
|
effectType = 1;
|
|
|
|
updateBuffer(textureAtlas, batch.outLineCommand);
|
|
|
|
auto* programStateOutline = batch.outLineCommand.getPipelineDescriptor().programState;
|
|
|
|
programStateOutline->setUniform(_effectColorLocation, &effectColor, sizeof(Vec4));
|
|
|
|
programStateOutline->setUniform(_effectTypeLocation, &effectType, sizeof(effectType));
|
|
|
|
batch.outLineCommand.init(_globalZOrder);
|
|
|
|
renderer->addCommand(&batch.outLineCommand);
|
|
|
|
}
|
2023-09-01 01:07:15 +08:00
|
|
|
|
2023-09-01 10:31:34 +08:00
|
|
|
// draw text
|
|
|
|
{
|
|
|
|
effectType = 0;
|
|
|
|
auto* programStateText = batch.textCommand.getPipelineDescriptor().programState;
|
2023-09-01 03:35:30 +08:00
|
|
|
|
2023-09-01 10:31:34 +08:00
|
|
|
programStateText->setUniform(_effectColorLocation, &effectColor, sizeof(effectColor));
|
|
|
|
programStateText->setUniform(_effectTypeLocation, &effectType, sizeof(effectType));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LabelEffect::NORMAL:
|
|
|
|
{
|
|
|
|
if (_shadowEnabled)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
Vec4 shadowColor = Vec4(_shadowColor4F.r, _shadowColor4F.g, _shadowColor4F.b, _shadowColor4F.a);
|
|
|
|
auto* programStateShadow = batch.shadowCommand.getPipelineDescriptor().programState;
|
|
|
|
programStateShadow->setUniform(_textColorLocation, &shadowColor, sizeof(Vec4));
|
|
|
|
batch.shadowCommand.init(_globalZOrder);
|
|
|
|
renderer->addCommand(&batch.shadowCommand);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LabelEffect::GLOW:
|
|
|
|
{
|
|
|
|
// draw shadow
|
|
|
|
if (_shadowEnabled)
|
|
|
|
{
|
|
|
|
Vec4 shadowColor = Vec4(_shadowColor4F.r, _shadowColor4F.g, _shadowColor4F.b, _shadowColor4F.a);
|
|
|
|
auto* programStateShadow = batch.shadowCommand.getPipelineDescriptor().programState;
|
|
|
|
programStateShadow->setUniform(_textColorLocation, &shadowColor, sizeof(Vec4));
|
|
|
|
programStateShadow->setUniform(_effectColorLocation, &shadowColor, sizeof(Vec4));
|
|
|
|
batch.shadowCommand.init(_globalZOrder);
|
|
|
|
renderer->addCommand(&batch.shadowCommand);
|
|
|
|
}
|
|
|
|
|
|
|
|
Vec4 effectColor(_effectColorF.r, _effectColorF.g, _effectColorF.b, _effectColorF.a);
|
|
|
|
batch.textCommand.getPipelineDescriptor().programState->setUniform(_effectColorLocation, &effectColor,
|
|
|
|
sizeof(Vec4));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_shadowEnabled)
|
|
|
|
{
|
|
|
|
Color3B oldColor = _realColor;
|
2019-11-23 20:27:39 +08:00
|
|
|
uint8_t oldOPacity = _displayedOpacity;
|
2021-12-25 10:04:45 +08:00
|
|
|
_displayedOpacity = _shadowColor4F.a * (oldOPacity / 255.0f) * 255;
|
2019-11-23 20:27:39 +08:00
|
|
|
setColor(Color3B(_shadowColor4F));
|
2021-12-25 10:04:45 +08:00
|
|
|
batch.shadowCommand.updateVertexBuffer(
|
|
|
|
textureAtlas->getQuads(), (unsigned int)(textureAtlas->getTotalQuads() * sizeof(V3F_C4B_T2F_Quad)));
|
2019-11-23 20:27:39 +08:00
|
|
|
batch.shadowCommand.init(_globalZOrder);
|
|
|
|
renderer->addCommand(&batch.shadowCommand);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
_displayedOpacity = oldOPacity;
|
|
|
|
setColor(oldColor);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
batch.textCommand.init(_globalZOrder);
|
|
|
|
renderer->addCommand(&batch.textCommand);
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void Label::draw(Renderer* renderer, const Mat4& transform, uint32_t flags)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (_batchNodes.empty() || _lengthOfString <= 0)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// Don't do calculate the culling if the transform was not updated
|
|
|
|
bool transformUpdated = flags & FLAGS_TRANSFORM_DIRTY;
|
2022-07-16 10:43:05 +08:00
|
|
|
#if AX_USE_CULLING
|
2019-11-23 20:27:39 +08:00
|
|
|
auto visitingCamera = Camera::getVisitingCamera();
|
2021-12-25 10:04:45 +08:00
|
|
|
auto defaultCamera = Camera::getDefaultCamera();
|
|
|
|
if (visitingCamera == defaultCamera)
|
|
|
|
{
|
|
|
|
_insideBounds = (transformUpdated || visitingCamera->isViewProjectionUpdated())
|
|
|
|
? renderer->checkVisibility(transform, _contentSize)
|
|
|
|
: _insideBounds;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_insideBounds = renderer->checkVisibility(transform, _contentSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_insideBounds)
|
|
|
|
#endif
|
|
|
|
{
|
2022-08-08 18:02:17 +08:00
|
|
|
ax::Mat4 matrixProjection = _director->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
|
2019-11-23 20:27:39 +08:00
|
|
|
if (!_shadowEnabled && (_currentLabelType == LabelType::BMFONT || _currentLabelType == LabelType::CHARMAP))
|
|
|
|
{
|
|
|
|
updateBlendState();
|
|
|
|
for (auto&& it : _letters)
|
|
|
|
{
|
|
|
|
it.second->updateTransform();
|
|
|
|
}
|
|
|
|
// ETC1 ALPHA supports for BMFONT & CHARMAP
|
|
|
|
auto textureAtlas = _batchNodes.at(0)->getTextureAtlas();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!textureAtlas->getTotalQuads())
|
2019-11-23 20:27:39 +08:00
|
|
|
return;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
auto texture = textureAtlas->getTexture();
|
2019-11-23 20:27:39 +08:00
|
|
|
auto& pipelineQuad = _quadCommand.getPipelineDescriptor();
|
|
|
|
pipelineQuad.programState->setUniform(_mvpMatrixLocation, matrixProjection.m, sizeof(matrixProjection.m));
|
|
|
|
pipelineQuad.programState->setTexture(texture->getBackendTexture());
|
2021-12-25 10:04:45 +08:00
|
|
|
_quadCommand.init(_globalZOrder, texture, _blendFunc, textureAtlas->getQuads(),
|
|
|
|
textureAtlas->getTotalQuads(), transform, flags);
|
2019-11-23 20:27:39 +08:00
|
|
|
renderer->addCommand(&_quadCommand);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-08-08 18:02:17 +08:00
|
|
|
ax::Mat4 matrixMVP = matrixProjection * transform;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
for (auto&& it : _letters)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
it.second->updateTransform();
|
|
|
|
}
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
if (_batchCommands.size() != _batchNodes.size())
|
|
|
|
{
|
|
|
|
_batchCommands.resize(_batchNodes.size());
|
|
|
|
updateShaderProgram();
|
|
|
|
}
|
|
|
|
|
|
|
|
updateBlendState();
|
|
|
|
|
|
|
|
for (auto&& batchNode : _batchNodes)
|
|
|
|
{
|
|
|
|
auto textureAtlas = batchNode->getTextureAtlas();
|
|
|
|
if (!textureAtlas->getTotalQuads())
|
2020-06-12 11:34:02 +08:00
|
|
|
continue;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto& batch = _batchCommands[i++];
|
2022-07-21 19:19:08 +08:00
|
|
|
for (auto&& command : batch.getCommandArray())
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto* programState = command->getPipelineDescriptor().programState;
|
2019-11-23 20:27:39 +08:00
|
|
|
Vec4 textColor(_textColorF.r, _textColorF.g, _textColorF.b, _textColorF.a);
|
|
|
|
programState->setUniform(_textColorLocation, &textColor, sizeof(Vec4));
|
|
|
|
programState->setTexture(textureAtlas->getTexture()->getBackendTexture());
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
batch.textCommand.getPipelineDescriptor().programState->setUniform(_mvpMatrixLocation, matrixMVP.m,
|
|
|
|
sizeof(matrixMVP.m));
|
|
|
|
batch.outLineCommand.getPipelineDescriptor().programState->setUniform(_mvpMatrixLocation, matrixMVP.m,
|
|
|
|
sizeof(matrixMVP.m));
|
2019-11-23 20:27:39 +08:00
|
|
|
updateEffectUniforms(batch, textureAtlas, renderer, transform);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateBlendState()
|
|
|
|
{
|
|
|
|
setOpacityModifyRGB(_blendFunc != BlendFunc::ALPHA_NON_PREMULTIPLIED);
|
2022-07-21 19:19:08 +08:00
|
|
|
for (auto&& batch : _batchCommands)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-21 19:19:08 +08:00
|
|
|
for (auto&& command : batch.getCommandArray())
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
|
|
|
auto& blendDescriptor = command->getPipelineDescriptor().blendDescriptor;
|
2019-11-23 20:27:39 +08:00
|
|
|
updateBlend(blendDescriptor, _blendFunc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
updateBlend(_quadCommand.getPipelineDescriptor().blendDescriptor, _blendFunc);
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void Label::visit(Renderer* renderer, const Mat4& parentTransform, uint32_t parentFlags)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!_visible || (_utf8Text.empty() && _children.empty()))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (_systemFontDirty || _contentDirty)
|
|
|
|
{
|
2022-01-03 13:39:18 +08:00
|
|
|
// Label overflow shrink fix #566
|
|
|
|
if (_overflow == Overflow::SHRINK && this->getRenderingFontSize() < _originalFontSize)
|
|
|
|
rescaleWithOriginalFontSize();
|
2023-09-01 10:31:34 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
updateContent();
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
uint32_t flags = processParentFlags(parentTransform, parentFlags);
|
|
|
|
|
|
|
|
if (!_utf8Text.empty() && _shadowEnabled && (_shadowDirty || (flags & FLAGS_DIRTY_MASK)))
|
|
|
|
{
|
|
|
|
_position.x += _shadowOffset.width;
|
|
|
|
_position.y += _shadowOffset.height;
|
|
|
|
_transformDirty = _inverseDirty = true;
|
|
|
|
|
|
|
|
_shadowTransform = transform(parentTransform);
|
|
|
|
|
|
|
|
_position.x -= _shadowOffset.width;
|
|
|
|
_position.y -= _shadowOffset.height;
|
|
|
|
_transformDirty = _inverseDirty = true;
|
|
|
|
|
|
|
|
_shadowDirty = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool visibleByCamera = isVisitableByVisitingCamera();
|
|
|
|
if (_children.empty() && !_textSprite && !visibleByCamera)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// IMPORTANT:
|
|
|
|
// To ease the migration to v3.0, we still support the Mat4 stack,
|
|
|
|
// but it is deprecated and your code should not rely on it
|
|
|
|
_director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
|
|
|
|
_director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW, _modelViewTransform);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (!_children.empty())
|
|
|
|
{
|
|
|
|
sortAllChildren();
|
|
|
|
|
|
|
|
int i = 0;
|
|
|
|
// draw children zOrder < 0
|
|
|
|
for (auto size = _children.size(); i < size; ++i)
|
|
|
|
{
|
|
|
|
auto node = _children.at(i);
|
|
|
|
|
|
|
|
if (node && node->getLocalZOrder() < 0)
|
|
|
|
node->visit(renderer, _modelViewTransform, flags);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
this->drawSelf(visibleByCamera, renderer, flags);
|
|
|
|
|
|
|
|
for (auto it = _children.cbegin() + i, itCend = _children.cend(); it != itCend; ++it)
|
|
|
|
{
|
|
|
|
(*it)->visit(renderer, _modelViewTransform, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
this->drawSelf(visibleByCamera, renderer, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
_director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::drawSelf(bool visibleByCamera, Renderer* renderer, uint32_t flags)
|
|
|
|
{
|
|
|
|
if (_textSprite)
|
|
|
|
{
|
|
|
|
if (_shadowNode)
|
|
|
|
{
|
|
|
|
_shadowNode->visit(renderer, _modelViewTransform, flags);
|
|
|
|
}
|
|
|
|
_textSprite->visit(renderer, _modelViewTransform, flags);
|
|
|
|
}
|
|
|
|
else if (visibleByCamera && !_utf8Text.empty())
|
|
|
|
{
|
|
|
|
draw(renderer, _modelViewTransform, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
void Label::setSystemFontName(std::string_view systemFont)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (systemFont != _systemFont)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_systemFont = systemFont;
|
2019-11-23 20:27:39 +08:00
|
|
|
_currentLabelType = LabelType::STRING_TEXTURE;
|
2021-12-25 10:04:45 +08:00
|
|
|
_systemFontDirty = true;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setSystemFontSize(float fontSize)
|
|
|
|
{
|
|
|
|
if (_systemFontSize != fontSize)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_systemFontSize = fontSize;
|
2019-11-23 20:27:39 +08:00
|
|
|
_originalFontSize = fontSize;
|
|
|
|
_currentLabelType = LabelType::STRING_TEXTURE;
|
2021-12-25 10:04:45 +08:00
|
|
|
_systemFontDirty = true;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
///// PROTOCOL STUFF
|
|
|
|
Sprite* Label::getLetter(int letterIndex)
|
|
|
|
{
|
|
|
|
Sprite* letter = nullptr;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if (_systemFontDirty || _currentLabelType == LabelType::STRING_TEXTURE)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto contentDirty = _contentDirty;
|
|
|
|
if (contentDirty)
|
|
|
|
{
|
|
|
|
updateContent();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_textSprite == nullptr && letterIndex < _lengthOfString)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
const auto& letterInfo = _lettersInfo[letterIndex];
|
|
|
|
if (!letterInfo.valid || letterInfo.atlasIndex < 0)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_letters.find(letterIndex) != _letters.end())
|
|
|
|
{
|
|
|
|
letter = _letters[letterIndex];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (letter == nullptr)
|
|
|
|
{
|
|
|
|
auto& letterDef = _fontAtlas->_letterDefinitions[letterInfo.utf32Char];
|
2021-12-25 10:04:45 +08:00
|
|
|
auto textureID = letterDef.textureID;
|
2019-11-23 20:27:39 +08:00
|
|
|
Rect uvRect;
|
|
|
|
uvRect.size.height = letterDef.height;
|
2021-12-25 10:04:45 +08:00
|
|
|
uvRect.size.width = letterDef.width;
|
|
|
|
uvRect.origin.x = letterDef.U;
|
|
|
|
uvRect.origin.y = letterDef.V;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (letterDef.width <= 0.f || letterDef.height <= 0.f)
|
|
|
|
{
|
|
|
|
letter = LabelLetter::create();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
this->updateBMFontScale();
|
2021-12-25 10:04:45 +08:00
|
|
|
letter =
|
|
|
|
LabelLetter::createWithTexture(_fontAtlas->getTexture(textureID), uvRect, letterDef.rotated);
|
2019-11-23 20:27:39 +08:00
|
|
|
letter->setTextureAtlas(_batchNodes.at(textureID)->getTextureAtlas());
|
|
|
|
letter->setAtlasIndex(letterInfo.atlasIndex);
|
2021-12-25 10:04:45 +08:00
|
|
|
auto px = letterInfo.positionX + _bmfontScale * uvRect.size.width / 2 +
|
|
|
|
_linesOffsetX[letterInfo.lineIndex];
|
2019-11-23 20:27:39 +08:00
|
|
|
auto py = letterInfo.positionY - _bmfontScale * uvRect.size.height / 2 + _letterOffsetY;
|
2021-12-25 10:04:45 +08:00
|
|
|
letter->setPosition(px, py);
|
2019-11-23 20:27:39 +08:00
|
|
|
letter->setOpacity(_realOpacity);
|
|
|
|
this->updateLetterSpriteScale(letter);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
addChild(letter);
|
|
|
|
_letters[letterIndex] = letter;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (false);
|
|
|
|
|
|
|
|
return letter;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setLineHeight(float height)
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(_currentLabelType != LabelType::STRING_TEXTURE, "Not supported system font!");
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (_lineHeight != height)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_lineHeight = height;
|
2019-11-23 20:27:39 +08:00
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
float Label::getLineHeight() const
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(_currentLabelType != LabelType::STRING_TEXTURE, "Not supported system font!");
|
2019-11-23 20:27:39 +08:00
|
|
|
return _textSprite ? 0.0f : _lineHeight * _bmfontScale;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setLineSpacing(float height)
|
|
|
|
{
|
|
|
|
if (_lineSpacing != height)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_lineSpacing = height;
|
2019-11-23 20:27:39 +08:00
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
float Label::getLineSpacing() const
|
|
|
|
{
|
|
|
|
return _lineSpacing;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setAdditionalKerning(float space)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (_currentLabelType != LabelType::STRING_TEXTURE)
|
|
|
|
{
|
|
|
|
if (_additionalKerning != space)
|
|
|
|
{
|
|
|
|
_additionalKerning = space;
|
2021-12-25 10:04:45 +08:00
|
|
|
_contentDirty = true;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2022-07-16 10:43:05 +08:00
|
|
|
AXLOG("Label::setAdditionalKerning not supported on LabelType::STRING_TEXTURE");
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
float Label::getAdditionalKerning() const
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(_currentLabelType != LabelType::STRING_TEXTURE, "Not supported system font!");
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
return _additionalKerning;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::computeStringNumLines()
|
|
|
|
{
|
|
|
|
int quantityOfLines = 1;
|
|
|
|
|
|
|
|
if (_utf32Text.empty())
|
|
|
|
{
|
|
|
|
_numberOfLines = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// count number of lines
|
|
|
|
size_t stringLen = _utf32Text.length();
|
|
|
|
for (size_t i = 0; i < stringLen - 1; ++i)
|
|
|
|
{
|
|
|
|
if (_utf32Text[i] == StringUtils::UnicodeCharacters::NewLine)
|
|
|
|
{
|
|
|
|
quantityOfLines++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
_numberOfLines = quantityOfLines;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Label::getStringNumLines()
|
|
|
|
{
|
|
|
|
if (_contentDirty)
|
|
|
|
{
|
|
|
|
updateContent();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_currentLabelType == LabelType::STRING_TEXTURE)
|
|
|
|
{
|
|
|
|
computeStringNumLines();
|
|
|
|
}
|
|
|
|
|
|
|
|
return _numberOfLines;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Label::getStringLength()
|
|
|
|
{
|
|
|
|
_lengthOfString = static_cast<int>(_utf32Text.length());
|
|
|
|
return _lengthOfString;
|
|
|
|
}
|
|
|
|
|
|
|
|
// RGBA protocol
|
|
|
|
void Label::setOpacityModifyRGB(bool isOpacityModifyRGB)
|
|
|
|
{
|
|
|
|
if (isOpacityModifyRGB != _isOpacityModifyRGB)
|
|
|
|
{
|
|
|
|
_isOpacityModifyRGB = isOpacityModifyRGB;
|
|
|
|
updateColor();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateDisplayedColor(const Color3B& parentColor)
|
|
|
|
{
|
|
|
|
Node::updateDisplayedColor(parentColor);
|
|
|
|
|
|
|
|
if (_textSprite)
|
|
|
|
{
|
|
|
|
_textSprite->updateDisplayedColor(_displayedColor);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_shadowNode)
|
|
|
|
{
|
|
|
|
_shadowNode->updateDisplayedColor(_displayedColor);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_underlineNode)
|
|
|
|
{
|
|
|
|
// FIXME: _underlineNode is not a sprite/label. It is a DrawNode
|
|
|
|
// and updating its color doesn't work. it must be re-drawn,
|
|
|
|
// which makes it super expensive to change update it frequently
|
|
|
|
// Correct solution is to update the DrawNode directly since we know it is
|
|
|
|
// a line. Returning a pointer to the line is an option
|
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto&& it : _letters)
|
|
|
|
{
|
|
|
|
it.second->updateDisplayedColor(_displayedColor);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateDisplayedOpacity(uint8_t parentOpacity)
|
|
|
|
{
|
|
|
|
Node::updateDisplayedOpacity(parentOpacity);
|
|
|
|
|
|
|
|
if (_textSprite)
|
|
|
|
{
|
|
|
|
_textSprite->updateDisplayedOpacity(_displayedOpacity);
|
|
|
|
if (_shadowNode)
|
|
|
|
{
|
|
|
|
_shadowNode->updateDisplayedOpacity(_displayedOpacity);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto&& it : _letters)
|
|
|
|
{
|
|
|
|
it.second->updateDisplayedOpacity(_displayedOpacity);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: it is not clear what is the difference between setTextColor() and setColor()
|
|
|
|
// if setTextColor() only changes the text and nothing but the text (no glow, no outline, not underline)
|
|
|
|
// that's fine but it should be documented
|
2021-12-25 10:04:45 +08:00
|
|
|
void Label::setTextColor(const Color4B& color)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(_currentLabelType == LabelType::TTF || _currentLabelType == LabelType::STRING_TEXTURE,
|
2021-12-25 10:04:45 +08:00
|
|
|
"Only supported system font and ttf!");
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (_currentLabelType == LabelType::STRING_TEXTURE && _textColor != color)
|
|
|
|
{
|
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_textColor = color;
|
2019-11-23 20:27:39 +08:00
|
|
|
_textColorF.r = _textColor.r / 255.0f;
|
|
|
|
_textColorF.g = _textColor.g / 255.0f;
|
|
|
|
_textColorF.b = _textColor.b / 255.0f;
|
|
|
|
_textColorF.a = _textColor.a / 255.0f;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateColor()
|
|
|
|
{
|
|
|
|
if (_batchNodes.empty())
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
Color4B color4(_displayedColor.r, _displayedColor.g, _displayedColor.b, _displayedOpacity);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// special opacity for premultiplied textures
|
|
|
|
if (_isOpacityModifyRGB)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
color4.r *= _displayedOpacity / 255.0f;
|
|
|
|
color4.g *= _displayedOpacity / 255.0f;
|
|
|
|
color4.b *= _displayedOpacity / 255.0f;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2022-08-08 18:02:17 +08:00
|
|
|
ax::TextureAtlas* textureAtlas;
|
2021-12-25 10:04:45 +08:00
|
|
|
V3F_C4B_T2F_Quad* quads;
|
|
|
|
for (auto&& batchNode : _batchNodes)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
textureAtlas = batchNode->getTextureAtlas();
|
2021-12-25 10:04:45 +08:00
|
|
|
quads = textureAtlas->getQuads();
|
|
|
|
auto count = textureAtlas->getTotalQuads();
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
for (int index = 0; index < count; ++index)
|
|
|
|
{
|
|
|
|
quads[index].bl.colors = color4;
|
|
|
|
quads[index].br.colors = color4;
|
|
|
|
quads[index].tl.colors = color4;
|
|
|
|
quads[index].tr.colors = color4;
|
2023-07-09 19:00:12 +08:00
|
|
|
textureAtlas->updateQuad(quads[index], index);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string Label::getDescription() const
|
|
|
|
{
|
|
|
|
char tmp[50];
|
2022-11-14 15:02:16 +08:00
|
|
|
snprintf(tmp, sizeof(tmp), "<Label | Tag = %d, Label = >", _tag);
|
2019-11-23 20:27:39 +08:00
|
|
|
std::string ret = tmp;
|
|
|
|
ret += _utf8Text;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-10-23 23:27:14 +08:00
|
|
|
const Vec2& Label::getContentSize() const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (_systemFontDirty || _contentDirty)
|
|
|
|
{
|
|
|
|
const_cast<Label*>(this)->updateContent();
|
|
|
|
}
|
|
|
|
return _contentSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
Rect Label::getBoundingBox() const
|
|
|
|
{
|
|
|
|
const_cast<Label*>(this)->getContentSize();
|
|
|
|
|
|
|
|
return Node::getBoundingBox();
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void Label::setBlendFunc(const BlendFunc& blendFunc)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_blendFunc = blendFunc;
|
2019-11-23 20:27:39 +08:00
|
|
|
_blendFuncDirty = true;
|
|
|
|
if (_textSprite)
|
|
|
|
{
|
|
|
|
_textSprite->setBlendFunc(blendFunc);
|
|
|
|
if (_shadowNode)
|
|
|
|
{
|
|
|
|
_shadowNode->setBlendFunc(blendFunc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::removeAllChildrenWithCleanup(bool cleanup)
|
|
|
|
{
|
|
|
|
Node::removeAllChildrenWithCleanup(cleanup);
|
|
|
|
_letters.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::removeChild(Node* child, bool cleanup /* = true */)
|
|
|
|
{
|
|
|
|
Node::removeChild(child, cleanup);
|
|
|
|
for (auto&& it : _letters)
|
|
|
|
{
|
|
|
|
if (it.second == child)
|
|
|
|
{
|
|
|
|
_letters.erase(it.first);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
FontDefinition Label::_getFontDefinition() const
|
|
|
|
{
|
|
|
|
FontDefinition systemFontDef;
|
|
|
|
|
|
|
|
std::string fontName = _systemFont;
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_fontAtlas && !_fontAtlas->getFontName().empty())
|
|
|
|
fontName = _fontAtlas->getFontName();
|
|
|
|
|
|
|
|
systemFontDef._fontName = fontName;
|
|
|
|
systemFontDef._fontSize = _systemFontSize;
|
|
|
|
systemFontDef._alignment = _hAlignment;
|
|
|
|
systemFontDef._vertAlignment = _vAlignment;
|
|
|
|
systemFontDef._dimensions.width = _labelWidth == 0.f ? _maxLineWidth : _labelWidth;
|
|
|
|
systemFontDef._dimensions.height = _labelHeight;
|
|
|
|
systemFontDef._fontFillColor.r = _textColor.r;
|
|
|
|
systemFontDef._fontFillColor.g = _textColor.g;
|
|
|
|
systemFontDef._fontFillColor.b = _textColor.b;
|
|
|
|
systemFontDef._fontAlpha = _textColor.a;
|
2019-11-23 20:27:39 +08:00
|
|
|
systemFontDef._shadow._shadowEnabled = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
systemFontDef._enableWrap = _enableWrap;
|
|
|
|
systemFontDef._overflow = (int)_overflow;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (_currLabelEffect == LabelEffect::OUTLINE && _outlineSize > 0.f)
|
|
|
|
{
|
|
|
|
systemFontDef._stroke._strokeEnabled = true;
|
2021-12-25 10:04:45 +08:00
|
|
|
systemFontDef._stroke._strokeSize = _outlineSize;
|
2019-11-23 20:27:39 +08:00
|
|
|
systemFontDef._stroke._strokeColor.r = _effectColorF.r * 255;
|
|
|
|
systemFontDef._stroke._strokeColor.g = _effectColorF.g * 255;
|
|
|
|
systemFontDef._stroke._strokeColor.b = _effectColorF.b * 255;
|
2021-12-25 10:04:45 +08:00
|
|
|
systemFontDef._stroke._strokeAlpha = _effectColorF.a * 255;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
systemFontDef._stroke._strokeEnabled = false;
|
|
|
|
}
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
#if (AX_TARGET_PLATFORM != AX_PLATFORM_ANDROID) && (AX_TARGET_PLATFORM != AX_PLATFORM_IOS)
|
2019-11-23 20:27:39 +08:00
|
|
|
if (systemFontDef._stroke._strokeEnabled)
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXLOGERROR("Stroke Currently only supported on iOS and Android!");
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
systemFontDef._stroke._strokeEnabled = false;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return systemFontDef;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setGlobalZOrder(float globalZOrder)
|
|
|
|
{
|
|
|
|
Node::setGlobalZOrder(globalZOrder);
|
|
|
|
if (_textSprite)
|
|
|
|
{
|
|
|
|
_textSprite->setGlobalZOrder(globalZOrder);
|
|
|
|
if (_shadowNode)
|
|
|
|
{
|
|
|
|
_shadowNode->setGlobalZOrder(globalZOrder);
|
|
|
|
}
|
|
|
|
}
|
2021-06-09 12:09:01 +08:00
|
|
|
|
|
|
|
if (_underlineNode)
|
|
|
|
{
|
|
|
|
_underlineNode->setGlobalZOrder(globalZOrder);
|
|
|
|
}
|
2021-06-16 09:18:43 +08:00
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
#if AX_LABEL_DEBUG_DRAW
|
2021-06-16 09:18:43 +08:00
|
|
|
_debugDrawNode->setGlobalZOrder(globalZOrder);
|
|
|
|
#endif
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
float Label::getRenderingFontSize() const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
float fontSize;
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_currentLabelType == LabelType::BMFONT)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
fontSize = _bmFontSize;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (_currentLabelType == LabelType::TTF)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
fontSize = this->getTTFConfig().fontSize;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (_currentLabelType == LabelType::STRING_TEXTURE)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
fontSize = _systemFontSize;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // FIXME: find a way to calculate char map font size
|
2019-11-23 20:27:39 +08:00
|
|
|
fontSize = this->getLineHeight();
|
|
|
|
}
|
|
|
|
return fontSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::enableWrap(bool enable)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (enable == _enableWrap || _overflow == Overflow::RESIZE_HEIGHT)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
this->_enableWrap = enable;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
this->rescaleWithOriginalFontSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool Label::isWrapEnabled() const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return this->_enableWrap;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::setOverflow(Overflow overflow)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_overflow == overflow)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
return;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (_currentLabelType == LabelType::CHARMAP)
|
|
|
|
{
|
|
|
|
if (overflow == Overflow::SHRINK)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (overflow == Overflow::RESIZE_HEIGHT)
|
|
|
|
{
|
|
|
|
this->setDimensions(_labelDimensions.width, 0);
|
2019-11-23 20:27:39 +08:00
|
|
|
this->enableWrap(true);
|
|
|
|
}
|
|
|
|
_overflow = overflow;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
this->rescaleWithOriginalFontSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
_contentDirty = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::rescaleWithOriginalFontSize()
|
|
|
|
{
|
|
|
|
auto renderingFontSize = this->getRenderingFontSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_originalFontSize - renderingFontSize >= 1)
|
|
|
|
{
|
2022-01-03 13:56:25 +08:00
|
|
|
this->scaleFontSize(_originalFontSize);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
Label::Overflow Label::getOverflow() const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return _overflow;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Label::updateLetterSpriteScale(Sprite* sprite)
|
|
|
|
{
|
|
|
|
if (_currentLabelType == LabelType::BMFONT && _bmFontSize > 0)
|
|
|
|
{
|
|
|
|
sprite->setScale(_bmfontScale);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (std::abs(_bmFontSize) < FLT_EPSILON)
|
|
|
|
{
|
|
|
|
sprite->setScale(0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sprite->setScale(1.0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-11 17:50:21 +08:00
|
|
|
NS_AX_END
|