Initial commit

engines/twp/font.h

@@ -0,0 +1,205 @@
+/* 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