charset.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 SCUMM_CHARSET_H
#define SCUMM_CHARSET_H

#include "common/scummsys.h"
#include "common/rect.h"
#include "graphics/sjis.h"
#include "scumm/charset_v7.h"
#include "scumm/scumm.h"
#include "scumm/gfx.h"

namespace Graphics {
class Font;
}

namespace Scumm {

class ScummEngine;
class NutRenderer;
struct VirtScreen;

static inline bool checkKSCode(byte hi, byte lo) {
    //hi : xx
    //lo : yy
    if ((0xA1 > lo) || (0xFE < lo)) {
        return false;
    }
    if ((hi >= 0xB0) && (hi <= 0xC8)) {
        return true;
    }
    return false;
}

static inline bool checkSJISCode(byte c) {
    if ((c >= 0x80 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfd))
        return true;
    return false;
}

static inline bool is2ByteCharacter(Common::Language lang, byte c) {
    if (lang == Common::JA_JPN)
        return (c >= 0x80 && c <= 0x9F) || (c >= 0xE0 && c <= 0xFD);
    else if (lang == Common::KO_KOR)
        return (c >= 0xB0 && c <= 0xD0);
    else if (lang == Common::ZH_TWN || lang == Common::ZH_CHN)
        return (c >= 0x80);
    return false;
}

class CharsetRenderer {
public:

    Common::Rect _str;

    int _top;
    int _left, _startLeft;
    int _right;

protected:
    byte _color;

public:
    bool _center;

    bool _hasMask;  // True if "removable" text is visible somewhere (should be called _hasText or so)
    VirtScreenNumber _textScreenID; // ID of the virtual screen on which the text is visible.

    bool _blitAlso;
    bool _firstChar;
    bool _disableOffsX;

protected:
    ScummEngine *_vm;
    int32 _curId;

public:
    CharsetRenderer(ScummEngine *vm);
    virtual ~CharsetRenderer();

    virtual void printChar(int chr, bool ignoreCharsetMask) = 0;
    virtual void drawChar(int chr, Graphics::Surface &s, int x, int y) {}

    virtual int getStringWidth(int arg, const byte *text);
    void addLinebreaks(int a, byte *str, int pos, int maxwidth);
    void translateColor();

    virtual void setCurID(int32 id) = 0;
    int getCurID() { return _curId; }

    virtual int getFontHeight() const = 0;
    virtual int getCharHeight(uint16 chr) const { return getFontHeight(); }
    virtual int getCharWidth(uint16 chr) const = 0;

    virtual void setColor(byte color, bool shadowModeSpecialFlag = false) { _color = color; translateColor(); }
    virtual byte getColor() { return _color; }

    void saveLoadWithSerializer(Common::Serializer &ser);

#ifdef USE_TTS
    virtual Common::U32String convertText(const Common::String &text, Common::Language language) const { return Common::U32String(text, _vm->getDialogCodePage()); }
#endif
};

class CharsetRendererCommon : public CharsetRenderer {
public:
    enum ShadowType {
        kNoShadowType,
        kNormalShadowType,
        kHorizontalShadowType,
        kOutlineShadowType
    };

    CharsetRendererCommon(ScummEngine *vm);

    void setCurID(int32 id) override;

    int getFontHeight() const override;

protected:
    const byte *_fontPtr;
    int _bitsPerPixel;
    int _fontHeight;
    int _numChars;

    byte _shadowColor;
    ShadowType _shadowType;
};

class CharsetRendererPC : public CharsetRendererCommon {
public:
    CharsetRendererPC(ScummEngine *vm) : CharsetRendererCommon(vm) { }

protected:
    virtual void setShadowMode(ShadowType mode);
    virtual void drawBits1(Graphics::Surface &dest, int x, int y, const byte *src, int drawTop, int width, int height);
    void drawBits1Kor(Graphics::Surface &dest, int x1, int y1, const byte *src, int drawTop, int width, int height);
};

class CharsetRendererClassic : public CharsetRendererPC {
protected:
    virtual void drawBitsN(const Graphics::Surface &s, byte *dst, const byte *src, byte bpp, int drawTop, int width, int height);
    void printCharIntern(bool is2byte, const byte *charPtr, int origWidth, int origHeight, int width, int height, VirtScreen *vs, bool ignoreCharsetMask);
    virtual bool prepareDraw(uint16 chr);

    int _width, _height, _origWidth, _origHeight;
    int _cjkSpacing;
    int _offsX, _offsY;
    const byte *_charPtr;

    // On which virtual screen will be drawn right now
    VirtScreenNumber _drawScreen;

public:
    CharsetRendererClassic(ScummEngine *vm, int cjkSpacing) : CharsetRendererPC(vm), _width(0), _height(0), _origWidth(0), _origHeight(0),
        _cjkSpacing(cjkSpacing), _offsX(0), _offsY(0), _charPtr(nullptr), _drawScreen(kMainVirtScreen) {}
    CharsetRendererClassic(ScummEngine *vm) : CharsetRendererClassic(vm, vm->_game.id == GID_INDY4 &&
                                     (vm->_game.platform == Common::kPlatformMacintosh || vm->_game.platform == Common::kPlatformDOS) &&
                                     vm->_language == Common::JA_JPN ? -3 : 0) {}

    void printChar(int chr, bool ignoreCharsetMask) override;
    void drawChar(int chr, Graphics::Surface &s, int x, int y) override;

    int getCharWidth(uint16 chr) const override;
};

#ifdef USE_RGB_COLOR
#ifndef DISABLE_TOWNS_DUAL_LAYER_MODE
class CharsetRendererTownsClassic : public CharsetRendererClassic {
public:
    CharsetRendererTownsClassic(ScummEngine *vm);

    int getCharWidth(uint16 chr) const override;
    int getFontHeight() const override;

private:
    void drawBitsN(const Graphics::Surface &s, byte *dst, const byte *src, byte bpp, int drawTop, int width, int height) override;
    bool prepareDraw(uint16 chr) override;
    void setupShadowMode();
    bool useFontRomCharacter(uint16 chr) const;
    void processCharsetColors();

    uint16 _sjisCurChar;
};
#endif
#endif

class CharsetRendererNES : public CharsetRendererCommon {
protected:
    byte *_trTable = nullptr;

    void drawBits1(Graphics::Surface &dest, int x, int y, const byte *src, int drawTop, int width, int height);

public:
    CharsetRendererNES(ScummEngine *vm) : CharsetRendererCommon(vm) {}

    void setCurID(int32 id) override {}
    void printChar(int chr, bool ignoreCharsetMask) override;
    void drawChar(int chr, Graphics::Surface &s, int x, int y) override;

    int getFontHeight() const override { return 8; }
    int getCharWidth(uint16 chr) const override { return 8; }
};

class CharsetRendererV3 : public CharsetRendererPC {
protected:
    virtual int getDrawWidthIntern(uint16 chr);
    virtual int getDrawHeightIntern(uint16 chr);
    virtual void setDrawCharIntern(uint16 chr) {}

    const byte *_widthTable = nullptr;

public:
    CharsetRendererV3(ScummEngine *vm) : CharsetRendererPC(vm) {}

    void printChar(int chr, bool ignoreCharsetMask) override;
    void drawChar(int chr, Graphics::Surface &s, int x, int y) override;
    void setCurID(int32 id) override;
    void setColor(byte color, bool shadowModeSpecialFlag) override;
    int getCharWidth(uint16 chr) const override;
};

class CharsetRendererTownsV3 : public CharsetRendererV3 {
public:
    CharsetRendererTownsV3(ScummEngine *vm);

    int getCharWidth(uint16 chr) const override;
    int getFontHeight() const override;

private:
    void setShadowMode(ShadowType mode) override;
    void drawBits1(Graphics::Surface &dest, int x, int y, const byte *src, int drawTop, int width, int height) override;
#ifndef DISABLE_TOWNS_DUAL_LAYER_MODE
    int getDrawWidthIntern(uint16 chr) override;
    int getDrawHeightIntern(uint16 chr) override;
    void setDrawCharIntern(uint16 chr) override;
#endif
    uint16 _sjisCurChar;
};

#ifdef USE_RGB_COLOR
class CharsetRendererPCE : public CharsetRendererV3 {
private:
    void drawBits1(Graphics::Surface &dest, int x, int y, const byte *src, int drawTop, int width, int height) override;

    int getDrawWidthIntern(uint16 chr) override;
    int getDrawHeightIntern(uint16 chr) override;
    void setDrawCharIntern(uint16 chr) override;

    uint16 _sjisCurChar;

public:
    CharsetRendererPCE(ScummEngine *vm) : CharsetRendererV3(vm), _sjisCurChar(0) {}

    void setColor(byte color, bool) override;
};
#endif

class CharsetRendererV2 : public CharsetRendererV3 {
protected:
    bool _deleteFontPtr;

public:
    CharsetRendererV2(ScummEngine *vm, Common::Language language);
    ~CharsetRendererV2() override;

    void setCurID(int32 id) override {}
    int getCharWidth(uint16 chr) const override { return 8; }

#ifdef USE_TTS
    Common::U32String convertText(const Common::String &text, Common::Language language) const override;
#endif
};

class CharsetRendererMac : public CharsetRendererCommon {
protected:
    const Graphics::Font *_font = nullptr;
    bool _useCorrectFontSpacing;
    bool _pad;
    int _lastTop;

    int getDrawWidthIntern(uint16 chr) const;
    void printCharInternal(int chr, int color, bool shadow, int x, int y);

    byte getTextColor();
    byte getTextShadowColor();

    Graphics::Surface *_glyphSurface;

public:
    CharsetRendererMac(ScummEngine *vm, const Common::Path &fontFile);
    ~CharsetRendererMac() override;

    void setCurID(int32 id) override;

    int getStringWidth(int arg, const byte *text) override;
    int getFontHeight() const override;
    int getCharWidth(uint16 chr) const override;
    void printChar(int chr, bool ignoreCharsetMask) override;
    void setColor(byte color, bool) override;
};

#ifdef ENABLE_SCUMM_7_8
class CharsetRendererV7 : public CharsetRendererClassic, public GlyphRenderer_v7 {
public:
    CharsetRendererV7(ScummEngine *vm);
    ~CharsetRendererV7() override {};

    void printChar(int, bool) override { error("CharsetRendererV7::printChar(): Unexpected call to deprecated function"); }

    int draw2byte(byte *buffer, Common::Rect &clipRect, int x, int y, int pitch, int16 col, uint16 chr) override;
    int drawCharV7(byte *buffer, Common::Rect &clipRect, int x, int y, int pitch, int16 col, TextStyleFlags flags, byte chr) override;
    int getCharWidth(uint16 chr) const override;
    int getCharHeight(uint16 chr) const override { return ((chr & 0x80) && _vm->_useCJKMode) ? _vm->_2byteHeight : _fontHeight; }
    int getFontHeight() const override { return _fontHeight; }
    int setFont(int) override { return 0; }
    bool newStyleWrapping() const override { return _newStyle; }
private:
    const bool _newStyle;
    const int _direction;
};

class CharsetRendererNut : public CharsetRenderer, public GlyphRenderer_v7 {
public:
    CharsetRendererNut(ScummEngine *vm);
    ~CharsetRendererNut() override;

    void printChar(int, bool) override { error("CharsetRendererNut::printChar(): Unexpected call to deprecated function"); }

    void setCurID(int32 id) override;
    int setFont(int id) override;
    bool newStyleWrapping() const override { return true; }

    int draw2byte(byte *buffer, Common::Rect &clipRect, int x, int y, int pitch, int16 col, uint16 chr) override;
    int drawCharV7(byte *buffer, Common::Rect &clipRect, int x, int y, int pitch, int16 col, TextStyleFlags flags, byte chr) override;

    int getFontHeight() const override;
    int getCharWidth(uint16 chr) const override;
    int getCharHeight(uint16 chr) const override;

private:
    NutRenderer *_fr[5];
    NutRenderer *_current;
};
#endif

} // End of namespace Scumm


#endif