font.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef TWP_FONT_H
#define TWP_FONT_H

#include "common/rect.h"
#include "common/hashmap.h"
#include "common/str.h"
#include "twp/spritesheet.h"
#include "twp/gfx.h"

namespace Common {
template<>
struct Hash<Common::u32char_type_t> : public UnaryFunction<Common::u32char_type_t, uint> {
    uint operator()(Common::u32char_type_t val) const { return (uint)val; }
};
} // namespace Common

namespace Twp {

struct KerningKey {
    int first;
    int second;
};
bool operator==(const KerningKey &l, const KerningKey &r);

} // namespace Twp

namespace Common {

template<>
struct Hash<Twp::KerningKey> : public Common::UnaryFunction<Twp::KerningKey, uint> {
    uint operator()(Twp::KerningKey val) const { return (uint)(val.first ^ val.second); }
};

} // namespace Common

namespace Twp {
typedef Common::u32char_type_t CodePoint;

// represents a glyph: a part of an image for a specific font character
struct Glyph {
    int advance;              // Offset to move horizontally to the next character.
    Common::Rect bounds;      // Bounding rectangle of the glyph, in coordinates relative to the baseline.
    Common::Rect textureRect; // Texture coordinates of the glyph inside the font's texture.
};

class Font {
public:
    virtual ~Font() = default;

    virtual int getLineHeight() = 0;
    virtual float getKerning(CodePoint prev, CodePoint next) = 0;
    virtual Glyph getGlyph(CodePoint chr) = 0;
    virtual Common::String getName() = 0;
};

// Represents a bitmap font from a spritesheet.
class GGFont : public Font {
public:
    ~GGFont() override;
    void load(const Common::String &path);

    int getLineHeight() final { return _lineHeight; }
    float getKerning(CodePoint prev, CodePoint next) final { return 0.f; }
    Glyph getGlyph(CodePoint chr) final;
    Common::String getName() final { return _name; }

private:
    Common::HashMap<CodePoint, Glyph> _glyphs;
    int _lineHeight = 0;
    Common::String _name;
};

struct Char {
    int id = 0;
    int x = 0;
    int y = 0;
    int w = 0;
    int h = 0;
    int xoff = 0;
    int yoff = 0;
    int xadv = 0;
    int page = 0;
    int chnl = 0;
    Common::String _letter;
};

class BmFont : public Font {
public:
    ~BmFont() override;
    void load(const Common::String &path);

    int getLineHeight() final { return _lnHeight; }
    float getKerning(CodePoint prev, CodePoint next) final;
    Glyph getGlyph(CodePoint chr) final;
    Common::String getName() final { return _name; }

private:
    Common::HashMap<CodePoint, Glyph> _glyphs;
    Common::HashMap<KerningKey, float> _kernings;
    int _lnHeight = 0;
    int _base = 0;
    int _scaleW = 0;
    int _scaleH = 0;
    int _pages = 0;
    int _packed = 0;
    Common::String _name;
};

enum TextHAlignment {
    thLeft,
    thCenter,
    thRight
};
enum TextVAlignment {
    tvTop,
    tvCenter,
    tvBottom
};

// This class allows to render a text.
//
// A text can contains color in hexadecimal with this format: #RRGGBB
class Text {
public:
    Text();
    Text(const Common::String &fontName, const Common::String &text, TextHAlignment hAlign = thCenter, TextVAlignment vAlign = tvCenter, float maxWidth = 0.0f, const Color &color = Color());

    void setText(const Common::String &text) {
        _txt = text;
        _dirty = true;
    }
    Common::String getText() const { return _txt; }

    void setColor(const Color &c) {
        _col = c;
        _dirty = true;
    }
    Color getColor() const { return _col; }

    void setMaxWidth(float maxW) {
        _maxW = maxW;
        _dirty = true;
    }
    float getMaxWidth() const { return _maxW; }

    void setHAlign(TextHAlignment align) {
        _hAlign = align;
        _dirty = true;
    }
    TextHAlignment getHAlign() const { return _hAlign; }

    void setVAlign(TextVAlignment align) {
        _vAlign = align;
        _dirty = true;
    }
    TextVAlignment getVAlign() const { return _vAlign; }

    void setFont(const Common::String &fontName);
    Common::SharedPtr<Font> getFont() { return _font; }
    Math::Vector2d getBounds();

    void draw(Gfx &gfx, const Math::Matrix4 &trsf = Math::Matrix4());

private:
    void update();

private:
    Common::SharedPtr<Font> _font;
    Common::String _fontName;
    Texture *_texture = nullptr;
    Common::String _txt;
    Color _col;
    TextHAlignment _hAlign = TextHAlignment::thLeft;
    TextVAlignment _vAlign = TextVAlignment::tvCenter;
    Common::Array<Vertex> _vertices;
    Math::Vector2d _bnds;
    float _maxW = 0.f;
    Common::Array<Common::Rect> _quads;
    bool _dirty = false;
};

} // namespace Twp

#endif