screen_eob.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 KYRA_SCREEN_EOB_H
#define KYRA_SCREEN_EOB_H
 
#ifdef ENABLE_EOB
 
#include "graphics/big5.h"
 
#include "kyra/graphics/screen.h"
 
namespace Kyra {
 
class EoBCoreEngine;
class SegaRenderer;
class SegaAnimator;
class Screen_EoB : public Screen {
friend class SegaRenderer;
public:
    // The purpose of this enum is to keep better track of which page is used
    // when and for which purpose. We use the pages for more backup operations
    // than the original and also have to deal with the different ports which
    // all do their own things. This is supposed to help avoid using pages that
    // are already in use for something else. It also allows for quick fixes
    // if necessary.
    enum {
        kSegaInitShapesPage     =   7,
        kSegaRenderPage         =   8,
        kDefeatMsgBackupPage    =   10,
        kCheckPwBackupPage      =   10,
        kSpellbookBackupPage    =   10,
        kEoB2ScriptHelperPage   =   12,
        kCampMenuBackupPage     =   12
    };
 
public:
    Screen_EoB(EoBCoreEngine *vm, OSystem *system);
    ~Screen_EoB() override;
 
    bool init() override;
 
    void setClearScreenDim(int dim);
    void clearCurDim();
    void clearCurDimOvl(int pageNum);
 
    void setMouseCursor(int x, int y, const byte *shape) override;
    void setMouseCursor(int x, int y, const byte *shape, const uint8 *ovl);
 
    void loadFileDataToPage(Common::SeekableReadStream *s, int pageNum, uint32 size);
 
    void printShadedText(const char *string, int x, int y, int col1, int col2, int shadowCol, int pitch = -1);
 
    static void eob2ChineseLZUncompress(byte *dest, uint32 destSize, Common::SeekableReadStream *src);
    void loadChineseEOB2LZBitmap(Common::SeekableReadStream *s, int pageNum, uint32 size);
    void loadBitmap(const char *filename, int tempPage, int dstPage, Palette *pal, bool skip = false) override;
    void loadEoBBitmap(const char *file, const uint8 *cgaMapping, int tempPage, int destPage, int convertToPage);
    void loadShapeSetBitmap(const char *file, int tempPage, int destPage);
 
    void convertPage(int srcPage, int dstPage, const uint8 *cgaMapping);
 
    void setScreenPalette(const Palette &pal) override;
    void getRealPalette(int num, uint8 *dst) override;
 
    uint8 *encodeShape(uint16 x, uint16 y, uint16 w, uint16 h, bool encode8bit = false, const uint8 *cgaMapping = 0);
    void drawShape(uint8 pageNum, const uint8 *shapeData, int x, int y, int sd = -1, int flags = 0, ...) override;
    void drawT1Shape(uint8 pageNum, const byte *t1data, int x, int y, int sd);
    const uint8 *scaleShape(const uint8 *shapeData, int blockDistance);
    const uint8 *scaleShapeStep(const uint8 *shp);
    const uint8 *generateShapeOverlay(const uint8 *shp, const uint8 *fadingTable);
 
    void setShapeFrame(int x1, int y1, int x2, int y2);
    void enableShapeBackgroundFading(bool enable);
    void setShapeFadingLevel(int val);
 
    void setGfxParameters(int x, int y, int col);
    void drawExplosion(int scale, int radius, int numElements, int stepSize, int aspectRatio, const uint8 *colorTable, int colorTableSize);
    void drawVortex(int numElements, int radius, int stepSize, int, int disorder, const uint8 *colorTable, int colorTableSize);
 
    void fadeTextColor(Palette *pal, int color, int rate);
    bool delayedFadePalStep(Palette *fadePal, Palette *destPal, int rate);
 
    void setTextColorMap(const uint8 *cmap) override {}
    int getRectSize(int w, int h) override;
 
    void setFadeTable(const uint8 *table);
    void createColorFadeTable(const uint8 *palData, uint8 *dst, uint8 rootColor, uint8 weight);
    void createHiColorFadeTable(const uint16 *palData, void *dst, uint8 rootColor, uint8 weight);
 
    const uint16 *getCGADitheringTable(int index) const;
    const uint8 *getEGADitheringTable() const;
    int bytesPerPixel() const;
 
    bool loadFont(FontId fontId, const char *filename) override;
 
    // FM-Towns specific
    void decodeSHP(const uint8 *data, int dstPage);
    void convertToHiColor(int page);
    void shadeRect(int x1, int y1, int x2, int y2, int shadingLevel);
 
    // PC-98 specific
    void selectPC98Palette(int palID, Palette &dest, int brightness = 0, bool set = false);
    void decodeBIN(const uint8 *src, uint8 *dst, uint16 inSize);
    void decodePC98PlanarBitmap(uint8 *srcDstBuffer, uint8 *tmpBuffer, uint16 size = 64000);
 
    struct PalCycleData {
        const int8 *data;
        uint8 delay;
    };
 
    void initPC98PaletteCycle(int palID, PalCycleData *data);
    void updatePC98PaletteCycle(int brightness);
 
    PalCycleData *_activePalCycle;
    uint8 *_cyclePalette;
 
    // Amiga specific
    void loadSpecialAmigaCPS(const char *fileName, int destPage, bool isGraphics);
    // This is a simple way of emulating the Amiga copper list palette magic for more than 32 colors.
    // I use colors 32 to 63 for these extra colors (which the Amiga copper sends to the color
    // registers on the fly at vertical beam position 120).
    void setDualPalettes(Palette &top, Palette &bottom);
 
    // SegaCD specific
    void sega_initGraphics();
    void sega_selectPalette(int srcPalID, int dstPalID, bool set = false);
    void sega_loadCustomPaletteData(Common::ReadStream *in);
    void sega_updatePaletteFaders(int palID);
    void sega_fadePalette(int delay, int16 brEnd, int dstPalID = -1, bool waitForCompletion = true, bool noUpdate = false);
    void sega_fadeToBlack(int delay) { sega_fadePalette(delay, -7); }
    void sega_fadeToWhite(int delay) { sega_fadePalette(delay, 7); }
    void sega_fadeToNeutral(int delay) { sega_fadePalette(delay, 0); }
    void sega_paletteOps(int16 opPal, int16 par1, int16 par2);
    void sega_setTextBuffer(uint8 *buffer, uint32 bufferSize);
    void sega_clearTextBuffer(uint8 col);
    void sega_loadTextBackground(const uint8 *src, uint16 size);
    void sega_drawTextBox(int pW, int pH, int x, int y, int w, int h, uint8 color1, uint8 color2);
    void sega_loadTextBufferToVRAM(uint16 srcOffset, uint16 addr, int size);
    void sega_gfxScale(uint8 *out, uint16 w, uint16 h, uint16 pitch, const uint8 *in, const uint16 *stampMap, const uint16 *traceVectors);
    void sega_drawClippedLine(int pW, int pH, int x, int y, int w, int h, uint8 color);
    uint8 *sega_convertShape(const uint8 *src, int w, int h, int pal, int hOffs = 0);
    void sega_encodeShapesFromSprites(const uint8 **dst, const uint8 *src, int numShapes, int w, int h, int pal, bool removeSprites = true);
 
    SegaRenderer *sega_getRenderer() const { return _segaRenderer; }
    SegaAnimator *sega_getAnimator() const { return _segaAnimator; }
 
private:
    void updateDirtyRects() override;
    void ditherRect(const uint8 *src, uint8 *dst, int dstPitch, int srcW, int srcH, int colorKey = -1);
 
    template<typename pixelType , bool shapeFading> void drawShapeSetPixel(uint8 *dst, uint8 col);
    void scaleShapeProcessLine2Bit(uint8 *&shpDst, const uint8 *&shpSrc, uint32 transOffsetDst, uint32 transOffsetSrc);
    void scaleShapeProcessLine4Bit(uint8 *&dst, const uint8 *&src);
    bool posWithinRect(int posX, int posY, int x1, int y1, int x2, int y2);
 
    void setPagePixelHiCol(int pageNum, int x, int y, int color);
 
    void generateEGADitheringTable(const Palette &pal);
    void generateCGADitheringTables(const uint8 *mappingData);
 
    typedef void (Screen_EoB::*DrawShapePlotFunc)(uint8*, uint8);
    DrawShapePlotFunc _drawShapeSetPixel;
 
    int _dsDiv, _dsRem, _dsScaleTrans;
    uint8 *_cgaScaleTable;
    int16 _gfxX, _gfxY;
    int _gfxCol;
    const uint8 *_gfxMaxY;
 
    int16 _dsX1, _dsX2, _dsY1, _dsY2;
 
    bool _dsBackgroundFading;
    int16 _dsBackgroundFadingXOffs;
    uint8 _shapeOverlay[16];
 
    uint8 *_dsTempPage;
    uint8 *_shpBuffer;
    uint8 *_hiColorConvertBuffer;
 
    uint16 *_cgaDitheringTables[2];
    const uint8 *_cgaMappingDefault;
 
    uint8 *_egaDitheringTable;
    uint8 *_egaDitheringTempPage;
 
    Common::String _cpsFilePattern;
 
    const uint16 _hiColorCursorColorKey;
 
    static const uint8 _egaMatchTable[];
    static const ScreenDim _screenDimTableIntl[];
    static const ScreenDim _screenDimTableZH[];
    static const int _screenDimTableCount;
 
    // SegaCD specific
    struct PaletteFader {
        PaletteFader() : _brCur(0), _brDest(0), _fadeIncr(0), _fadeDelay(0), _fadeTimer(0), _needRefresh(false) {}
        int16 _brCur;
        int16 _brDest;
        int16 _fadeIncr;
        int16 _fadeDelay;
        int16 _fadeTimer;
        bool _needRefresh;
    };
 
    PaletteFader *_palFaders;
    bool _specialColorReplace;
    SegaRenderer *_segaRenderer;
    SegaAnimator *_segaAnimator;
    uint16 _segaCurPalette[64];
    uint16 *_segaCustomPalettes;
    uint8 *_defaultRenderBuffer;
    int _defaultRenderBufferSize;
 
    Common::SharedPtr<Graphics::Big5Font> _big5;
};
 
class ChineseTwoByteFontEoB final : public Font {
public:
    ChineseTwoByteFontEoB(Common::SharedPtr<Graphics::Big5Font> big5, Font *singleByte) : _big5(big5), _singleByte(singleByte), _border(false), _colorMap(nullptr) {}
 
    virtual Type getType() const override { return kBIG5; }
 
    bool load(Common::SeekableReadStream &data) override {
        return _singleByte->load(data);
    }
 
    void setStyles(int styles) override { _border = (styles & kStyleBorder); _singleByte->setStyles(styles); }
    int getHeight() const override { return MAX(_big5->getFontHeight(), _singleByte->getHeight()); }
    int getWidth() const override { return MAX(_big5->kChineseTraditionalWidth + 2, _singleByte->getWidth()); }
    void setColorMap(const uint8 *src) override { _colorMap = src; _singleByte->setColorMap(src); }
    int getCharWidth(uint16 c) const override;
    int getCharHeight(uint16 c) const override;
    void drawChar(uint16 c, byte *dst, int pitch, int bpp) const override;
 
private:
    uint16 translateBig5(uint16 in) const;
    Common::SharedPtr<Graphics::Big5Font> _big5;
    Common::ScopedPtr<Font> _singleByte;
    bool _border;
    const uint8 *_colorMap;
};
 
class OldDOSFont : public Font {
public:
    OldDOSFont(Common::RenderMode mode, uint8 shadowColor, bool remapCharacters = true);
    ~OldDOSFont() override;
 
    bool load(Common::SeekableReadStream &file) override;
    bool loadPCBIOSTall();
    Type getType() const override { return kASCII; }
    int getHeight() const override { return _height; }
    int getWidth() const override { return _width; }
    bool usesOverlay() const override { return _useOverlay; }
    int getCharWidth(uint16 c) const override;
    void setColorMap(const uint8 *src) override;
    void setHiColorMap(const uint32 *src) override { _hiColorMap = src; }
    void setStyles(int styles) override { _style = styles; }
    void drawChar(uint16 c, byte *dst, int pitch, int bpp) const override;
 
protected:
    void unload();
 
    int _style;
    const uint8 *_colorMap8bit;
    uint8 *_data;
    uint16 *_bitmapOffsets;
    int _width, _height;
    int _numGlyphs;
    uint8 _shadowColor;
 
    uint16 _numGlyphsMax;
    bool _useOverlay;
    int _scaleV;
 
private:
    void drawCharIntern(uint16 c, byte *dst, int pitch, int bpp, int col1, int col2) const;
    virtual uint16 convert(uint16 c) const;
    Common::RenderMode _renderMode;
    const uint32 *_hiColorMap;
    bool _remapCharacters;
 
    static uint16 *_cgaDitheringTable;
    static int _numRef;
};
 
class Resource;
class AmigaDOSFont : public Font {
public:
    AmigaDOSFont(Resource *res, bool needsLocalizedFont = false);
    ~AmigaDOSFont() override { unload(); }
 
    bool load(Common::SeekableReadStream &file) override;
    Type getType() const override { return kASCII; }
    int getHeight() const override { return _height; }
    int getWidth() const override { return _width; }
    int getCharWidth(uint16 c) const override;
    void setColorMap(const uint8 *src) override { _colorMap = src; }
    void drawChar(uint16 c, byte *dst, int pitch, int) const override;
 
    static void errorDialog(int index);
 
private:
    void unload();
 
    struct TextFont {
        TextFont() : data(0), bitmap(0), location(0), spacing(0), kerning(0), height(0), width(0), baseLine(0), firstChar(0), lastChar(0), modulo(0) {}
        ~TextFont() {
            delete[] data;
        }
 
        uint16 height;
        uint16 width;
        uint16 baseLine;
        uint8 firstChar;
        uint8 lastChar;
        uint16 modulo;
        const uint8 *data;
        const uint8 *bitmap;
        const uint16 *location;
        const int16 *spacing;
        const int16 *kerning;
    };
 
    TextFont *loadContentFile(const Common::Path &fileName);
    void selectMode(int mode);
 
    struct FontContent {
        FontContent() : height(0), style(0), flags(0) {}
        ~FontContent() {
            data.reset();
        }
 
        Common::String contentFile;
        Common::SharedPtr<TextFont> data;
        uint16 height;
        uint8 style;
        uint8 flags;
    };
 
    int _width, _height;
    uint8 _first, _last;
    FontContent *_content;
    uint16 _numElements;
    uint16 _selectedElement;
 
    const uint8 *_colorMap;
    const uint16 _maxPathLen;
    const bool _needsLocalizedFont;
 
    static uint8 _errorDialogDisplayed;
 
    Resource *_res;
};
 
class SJISFontEoB1PC98 : public SJISFont {
public:
    SJISFontEoB1PC98(Common::SharedPtr<Graphics::FontSJIS> &font, /*uint8 shadowColor,*/ const uint16 *convTable1, const uint16 *convTable2);
    ~SJISFontEoB1PC98() override {}
    int getCharWidth(uint16 c) const override;
    void drawChar(uint16 c, byte *dst, int pitch, int) const override;
 
private:
    uint16 convert(uint16 c) const;
    const uint16 *_convTable1, *_convTable2;
    bool _defaultConv;
};
 
class SJISFontEoB2PC98 : public SJISFont {
public:
    SJISFontEoB2PC98(Common::SharedPtr<Graphics::FontSJIS> &font, /*uint8 shadowColor,*/ const char *convTable1, const char *convTable2);
    ~SJISFontEoB2PC98() override {}
    int getCharWidth(uint16 c) const override;
    void drawChar(uint16 c, byte *dst, int pitch, int) const override;
 
private:
    uint16 convert(uint16 c) const;
    const char *_convTable1, *_convTable2;
    //bool _defaultConv;
};
 
class Font12x12PC98 : public OldDOSFont{
public:
    Font12x12PC98(uint8 shadowColor, const uint16 *convTable1, const uint16 *convTable2, const uint8 *lookupTable);
    ~Font12x12PC98() override;
    bool usesOverlay() const override { return true; }
    Type getType() const override { return kJIS_X0201; }
    int getHeight() const override { return _height >> 1; }
    int getWidth() const override { return _width >> 1; }
    int getCharWidth(uint16 c) const override { return _width >> 1; };
    bool load(Common::SeekableReadStream &file) override;
 
private:
    uint16 convert(uint16 c) const override;
    const uint16 *_convTable1, *_convTable2;
    uint16 *_bmpOffs;
};
 
class PC98Font : public OldDOSFont {
public:
    PC98Font(uint8 shadowColor, bool useOverlay, int scaleV, const uint8 *convTable1 = 0, const char *convTable2 = 0, const char *convTable3 = 0);
    ~PC98Font() override {}
    bool load(Common::SeekableReadStream &file) override;
    int getHeight() const override { return _outputHeight; }
    int getWidth() const override { return _outputWidth; }
    int getCharWidth(uint16 c) const override { return _outputWidth; };
    Type getType() const override { return _type; }
 
private:
    uint16 convert(uint16 c) const override;
    uint16 makeTwoByte(uint16 c) const;
 
    const uint8 *_convTable1;
    const char *_convTable2, *_convTable3;
 
    int _outputHeight;
    int _outputWidth;
    const Type _type;
};
 
class SJISFontLarge : public SJISFont {
public:
    SJISFontLarge(Common::SharedPtr<Graphics::FontSJIS> &font);
    ~SJISFontLarge() override {}
 
    int getHeight() const override;
    int getWidth() const override;
    int getCharWidth(uint16 c) const override;
 
    bool usesOverlay() const override { return false; }
    void drawChar(uint16 c, byte *dst, int pitch, int) const override;
};
 
class SJISFont12x12 : public Font {
public:
    SJISFont12x12(const uint16 *searchTable);
    ~SJISFont12x12() override { unload(); }
 
    bool load(Common::SeekableReadStream &file) override;
    Type getType() const override { return kSJIS; }
    bool usesOverlay() const override { return true; }
    int getHeight() const override { return _height; }
    int getWidth() const override { return _width; }
    int getCharWidth(uint16 c) const override { return _width; }
    void setColorMap(const uint8 *src) override { _colorMap = src; }
    void drawChar(uint16 c, byte *dst, int pitch, int) const override;
 
private:
    void unload();
 
    uint8 *_data;
    Common::HashMap<uint16, uint8> _searchTable;
 
    const uint8 *_colorMap;
    const int _height, _width;
};
 
class SegaCDFont : public Font {
public:
    SegaCDFont(Common::Language lang, const uint16 *convTable1, const uint16 *convTable2, const uint8 *widthTable1, const uint8 *widthTable2, const uint8 *widthTable3);
    ~SegaCDFont() override;
 
    bool load(Common::SeekableReadStream &file) override;
    Type getType() const override { return _forceOneByte ? kASCII : kSJIS; }
    int getHeight() const override { return _height; }
    int getWidth() const override { return _width; }
    int getCharWidth(uint16 c) const override;
    int getCharHeight(uint16 c) const override;
    void setStyles(int styles) override;
    void setColorMap(const uint8 *src) override { _colorMap = src; }
    void drawChar(uint16 c, byte *dst, int pitch, int bpp) const override { drawChar(c, dst, pitch, 0, 0); }
    void drawChar(uint16 c, byte *dst, int pitch, int xOffs, int yOffs) const override;
 
private:
    const uint8 *getGlyphData(uint16 c, uint8 &charWidth, uint8 &charHeight, uint8 &pitch) const;
 
    const uint8 *_data;
    const uint8 *_buffer;
    bool _forceTwoByte;
    bool _forceOneByte;
    Common::Language _lang;
    uint8 _style;
 
    const uint8 *_colorMap;
    const int _height, _width;
    const uint16 *_convTable1, *_convTable2;
    const uint8 *_widthTable1, *_widthTable2, *_widthTable3;
};
 
} // End of namespace Kyra
 
#endif // ENABLE_EOB
 
#endif