mirror of
https://github.com/libretro/scummvm.git
synced 2025-01-09 03:10:22 +00:00
308 lines
8.8 KiB
C++
308 lines
8.8 KiB
C++
/* 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/>.
|
|
*
|
|
*/
|
|
|
|
// Font management and font drawing header file
|
|
|
|
#ifndef SAGA_FONT_H
|
|
#define SAGA_FONT_H
|
|
|
|
#include "common/list.h"
|
|
#include "saga/gfx.h"
|
|
|
|
namespace Graphics {
|
|
class FontSJIS;
|
|
}
|
|
|
|
namespace Saga {
|
|
|
|
#define FONT_SHOWUNDEFINED 1 // Define to draw undefined characters * as ?'s
|
|
|
|
// The first defined character (!) is the only one that may
|
|
// have a valid offset of '0'
|
|
#define FONT_FIRSTCHAR 33
|
|
|
|
#define FONT_CH_TAB 9
|
|
#define FONT_CH_SPACE 32
|
|
#define FONT_CH_QMARK 63
|
|
|
|
// Minimum font header size without font data
|
|
// (6 + 512 + 256 + 256 + 256 )
|
|
#define FONT_DESCSIZE 1286
|
|
|
|
#define FONT_CHARCOUNT 256
|
|
#define FONT_CHARMASK 0xFFU
|
|
|
|
#define SAGA_FONT_HEADER_LEN 6
|
|
|
|
#define TEXT_CENTERLIMIT 50
|
|
#define TEXT_MARGIN 10
|
|
#define TEXT_LINESPACING 2
|
|
|
|
enum FontEffectFlags {
|
|
kFontNormal = 0,
|
|
kFontOutline = 1 << 0,
|
|
kFontShadow = 1 << 1,
|
|
kFontBold = 1 << 2,
|
|
kFontCentered = 1 << 3,
|
|
kFontDontmap = 1 << 4
|
|
};
|
|
|
|
enum KnownFont {
|
|
kKnownFontSmall,
|
|
kKnownFontMedium,
|
|
kKnownFontBig,
|
|
|
|
kKnownFontPause,
|
|
kKnownFontScript,
|
|
kKnownFontVerb
|
|
};
|
|
|
|
struct TextListEntry {
|
|
bool display;
|
|
bool useRect;
|
|
Common::Point point;
|
|
Common::Rect rect;
|
|
KnownColor knownColor;
|
|
KnownColor effectKnownColor;
|
|
FontEffectFlags flags;
|
|
KnownFont font;
|
|
const char *text;
|
|
|
|
TextListEntry() {
|
|
display = false;
|
|
useRect = false;
|
|
// point initialized by Common::Point constructor
|
|
// rect initialized by Common::Rect constructor
|
|
knownColor = kKnownColorTransparent;
|
|
effectKnownColor = kKnownColorTransparent;
|
|
flags = kFontNormal;
|
|
font = kKnownFontSmall;
|
|
text = nullptr;
|
|
}
|
|
|
|
bool operator==(const TextListEntry &e) const {
|
|
return 0 == memcmp(this, &e, sizeof(*this));
|
|
}
|
|
};
|
|
|
|
class TextList: public Common::List<TextListEntry> {
|
|
public:
|
|
|
|
TextListEntry *addEntry(const TextListEntry &entry) {
|
|
Common::List<TextListEntry>::push_back(entry);
|
|
return &*--Common::List<TextListEntry>::end();
|
|
}
|
|
};
|
|
|
|
struct FontHeader {
|
|
int charHeight;
|
|
int charWidth;
|
|
int rowLength;
|
|
};
|
|
|
|
struct FontCharEntry {
|
|
int index;
|
|
int byteWidth;
|
|
int width;
|
|
int flag;
|
|
int tracking;
|
|
};
|
|
|
|
struct FontStyle {
|
|
FontHeader header;
|
|
FontCharEntry fontCharEntry[256];
|
|
#ifndef __DS__
|
|
ByteArray font;
|
|
#else
|
|
byte* font;
|
|
#endif
|
|
};
|
|
|
|
struct FontData {
|
|
FontStyle normal;
|
|
FontStyle outline;
|
|
};
|
|
|
|
class Font {
|
|
public:
|
|
Font(SagaEngine *vm) : _vm(vm) {}
|
|
virtual ~Font() {}
|
|
|
|
int getStringWidth(KnownFont font, const char *text, size_t count, FontEffectFlags flags) {
|
|
return getStringWidth(knownFont2FontIdx(font), text, count, flags);
|
|
}
|
|
|
|
int getHeight(KnownFont font) {
|
|
return getHeight(knownFont2FontIdx(font));
|
|
}
|
|
|
|
int getHeight(KnownFont font, const char *text, int width, FontEffectFlags flags) {
|
|
return getHeight(knownFont2FontIdx(font), text, width, flags);
|
|
}
|
|
|
|
void textDraw(KnownFont font, const char *string, const Common::Point &point, int color, int effectColor, FontEffectFlags flags) {
|
|
textDraw(knownFont2FontIdx(font), string, point, color, effectColor, flags);
|
|
}
|
|
|
|
void textDrawRect(KnownFont font, const char *text, const Common::Rect &rect, int color, int effectColor, FontEffectFlags flags) {
|
|
textDrawRect(knownFont2FontIdx(font), text, rect, color, effectColor, flags);
|
|
}
|
|
|
|
virtual void setFontMapping(int) {}
|
|
|
|
protected:
|
|
enum FontId {
|
|
kSmallFont,
|
|
kMediumFont,
|
|
kBigFont,
|
|
kIHNMUnknown,
|
|
kIHNMFont8,
|
|
kIHNMUnknown2,
|
|
kIHNMMainFont
|
|
};
|
|
|
|
SagaEngine *_vm;
|
|
|
|
private:
|
|
FontId knownFont2FontIdx(KnownFont font);
|
|
void textDraw(FontId fontId, const char *string, const Common::Point &point, int color, int effectColor, FontEffectFlags flags);
|
|
|
|
virtual void textDrawRect(FontId fontId, const char *text, const Common::Rect &rect, int color, int effectColor, FontEffectFlags flags) = 0;
|
|
virtual int translateChar(int charId) = 0;
|
|
virtual int getStringLength(const char *text) = 0;
|
|
virtual int getStringWidth(FontId fontId, const char *text, size_t count, FontEffectFlags flags) = 0;
|
|
virtual int getHeight(FontId fontId, const char *text, int width, FontEffectFlags flags) = 0;
|
|
virtual int getHeight(FontId fontId) = 0;
|
|
virtual bool valid(FontId) = 0;
|
|
virtual void draw(FontId fontId, const char *text, size_t count, const Common::Point &point, int color, int effectColor, FontEffectFlags flags) = 0;
|
|
};
|
|
|
|
class DefaultFont : public Font {
|
|
public:
|
|
DefaultFont(SagaEngine *vm);
|
|
~DefaultFont() override;
|
|
|
|
void setFontMapping(int mapping) override {
|
|
_fontMapping = mapping;
|
|
}
|
|
|
|
private:
|
|
void textDrawRect(FontId fontId, const char *text, const Common::Rect &rect, int color, int effectColor, FontEffectFlags flags) override;
|
|
int translateChar(int charId) override;
|
|
int getStringLength(const char *text) override {
|
|
return strlen(text);
|
|
}
|
|
|
|
int getStringWidth(FontId fontId, const char *text, size_t count, FontEffectFlags flags) override;
|
|
int getHeight(FontId fontId, const char *text, int width, FontEffectFlags flags) override;
|
|
int getHeight(FontId fontId) override {
|
|
return getFont(fontId)->normal.header.charHeight;
|
|
}
|
|
|
|
int getHeight(FontId fontId, const char *text);
|
|
|
|
void validate(FontId fontId) {
|
|
if (!valid(fontId)) {
|
|
error("Font::validate: Invalid font id");
|
|
}
|
|
}
|
|
|
|
bool valid(FontId fontId) override {
|
|
return (uint(fontId) < _fonts.size());
|
|
}
|
|
|
|
FontData *getFont(FontId fontId) {
|
|
validate(fontId);
|
|
return &_fonts[fontId];
|
|
}
|
|
|
|
void draw(FontId fontId, const char *text, size_t count, const Common::Point &point, int color, int effectColor, FontEffectFlags flags) override;
|
|
void outFont(const FontStyle &drawFont, const char *text, size_t count, const Common::Point &point, int color, FontEffectFlags flags);
|
|
void loadFont(FontData *font, uint32 fontResourceId);
|
|
void loadFont(FontData *font, const ByteArray& fontResourceData, bool isBigEndian);
|
|
void loadChineseFontIHNM(FontData *font, uint32 fontResourceId);
|
|
void loadChineseFontITE(const Common::Path &fileName);
|
|
void loadKoreanFontIHNM(const Common::Path &fileName);
|
|
void saveBig5Index(byte head, byte tail, uint curIdx);
|
|
void createOutline(FontData *font);
|
|
void blitGlyph(const Common::Point &textPoint, const byte* bitmap, int charWidth, int charHeight, int rowLength, byte color);
|
|
|
|
int getByteLen(int numBits) const {
|
|
int byteLength = numBits / 8;
|
|
|
|
if (numBits % 8) {
|
|
byteLength++;
|
|
}
|
|
|
|
return byteLength;
|
|
}
|
|
|
|
static const int _charMap[128];
|
|
|
|
Common::Array<FontData> _fonts;
|
|
int _fontMapping;
|
|
|
|
byte *_chineseFont;
|
|
Common::Array<int> _chineseFontIndex;
|
|
int _cjkFontWidth;
|
|
int _cjkFontHeight;
|
|
|
|
byte *_koreanFont;
|
|
|
|
static const int kIHNMKoreanGlyphBytes = 32;
|
|
static const int kIHNMKoreanInitials = 20;
|
|
static const int kIHNMKoreanInitialVariants = 8;
|
|
static const int kIHNMKoreanMidOffset = kIHNMKoreanInitialVariants * kIHNMKoreanInitials;
|
|
static const int kIHNMKoreanMids = 22;
|
|
static const int kIHNMKoreanMidVariants = 4;
|
|
static const int kIHNMKoreanFinalsOffset = kIHNMKoreanMidOffset + kIHNMKoreanMids * kIHNMKoreanMidVariants;
|
|
static const int kIHNMKoreanFinals = 28;
|
|
static const int kIHNMKoreanFinalVariants = 4;
|
|
static const int kIHNMKoreanNonJamoOffset = kIHNMKoreanFinalsOffset + kIHNMKoreanFinals * kIHNMKoreanFinalVariants;
|
|
static const int kIHNMKoreanNonJamo = 126;
|
|
};
|
|
|
|
class SJISFont : public Font {
|
|
public:
|
|
SJISFont(SagaEngine *vm);
|
|
~SJISFont() override;
|
|
|
|
private:
|
|
void textDrawRect(FontId fontId, const char *text, const Common::Rect &rect, int color, int effectColor, FontEffectFlags flags) override;
|
|
int translateChar(int charId) override { return charId; }
|
|
int getStringLength(const char *text) override;
|
|
int getStringWidth(FontId fontId, const char *text, size_t count, FontEffectFlags flags) override;
|
|
int getHeight(FontId fontId, const char *text, int width, FontEffectFlags flags) override;
|
|
int getHeight(FontId fontId) override;
|
|
bool valid(FontId fontId) override { return fontId != kBigFont; }
|
|
|
|
void draw(FontId fontId, const char *text, size_t count, const Common::Point &point, int color, int effectColor, FontEffectFlags flags) override;
|
|
|
|
uint16 fetchChar(const char *&s) const;
|
|
bool preventLineBreakForCharacter(uint16 ch) const;
|
|
|
|
Graphics::FontSJIS *_font;
|
|
};
|
|
|
|
} // End of namespace Saga
|
|
|
|
#endif
|