celobj32.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 SCI_GRAPHICS_CELOBJ32_H
#define SCI_GRAPHICS_CELOBJ32_H

#include "common/rational.h"
#include "common/rect.h"
#include "sci/resource/resource.h"
#include "sci/engine/vm_types.h"
#include "sci/util.h"

namespace Sci {
typedef Common::Rational Ratio;

// SCI32 has four different coordinate systems:
// 1. low resolution, 2. game/script resolution, 3. text/bitmap resolution,
// 4. screen resolution
//
// In CelObj, these values are used when there is no baked in resolution of
// cels.
//
// In ScreenItem, it is used when deciding which path to take to calculate
// dimensions.
enum {
    kLowResX = 320,
    kLowResY = 200
};

enum CelType {
    kCelTypeView  = 0,
    kCelTypePic   = 1,
    kCelTypeMem   = 2,
    kCelTypeColor = 3
};

enum CelCompressionType {
    kCelCompressionNone    = 0,
    kCelCompressionRLE     = 138,
    kCelCompressionInvalid = 1000
};

struct CelInfo32 {
    CelType type;

    GuiResourceId resourceId;

    int16 loopNo;

    int16 celNo;

    reg_t bitmap;

    uint8 color;

    CelInfo32() :
        // In SSCI, color is left uninitialised
        type(kCelTypeMem),
        resourceId(0),
        loopNo(0),
        celNo(0),
        bitmap(NULL_REG),
        color(0) {}

    // This is the equivalence criteria used by CelObj::searchCache in at least
    // SSCI SQ6. Notably, it does not check the color field.
    inline bool operator==(const CelInfo32 &other) {
        return (
            type == other.type &&
            resourceId == other.resourceId &&
            loopNo == other.loopNo &&
            celNo == other.celNo &&
            bitmap == other.bitmap
        );
    }

    inline bool operator!=(const CelInfo32 &other) {
        return !(*this == other);
    }

    inline Common::String toString() const {
        switch (type) {
        case kCelTypeView:
            return Common::String::format("view %u, loop %d, cel %d", resourceId, loopNo, celNo);
        case kCelTypePic:
            return Common::String::format("pic %u, cel %d", resourceId, celNo);
        case kCelTypeColor:
            return Common::String::format("color %d", color);
        case kCelTypeMem:
            return Common::String::format("mem %04x:%04x", PRINT_REG(bitmap));
        default:
            return Common::String::format("unknown cel type: %d", type);
        }
    }
};

class CelObj;
struct CelCacheEntry {
    int id;
    Common::ScopedPtr<CelObj> celObj;
    CelCacheEntry() : id(0) {}
};

typedef Common::Array<CelCacheEntry> CelCache;

#pragma mark -
#pragma mark CelScaler

enum {
    kCelScalerTableSize = 4096
};

struct CelScalerTable {
    int valuesX[kCelScalerTableSize];

    Ratio scaleX;

    int valuesY[kCelScalerTableSize];

    Ratio scaleY;
};

class CelScaler {
    CelScalerTable _scaleTables[2];

    int _activeIndex;

    void activateScaleTables(const Ratio &scaleX, const Ratio &scaleY);

    void buildLookupTable(int *table, const Ratio &ratio, const int size);

public:
    CelScaler() :
        _scaleTables(),
        _activeIndex(0) {
        CelScalerTable &table = _scaleTables[0];
        table.scaleX = Ratio();
        table.scaleY = Ratio();
        for (int i = 0; i < ARRAYSIZE(table.valuesX); ++i) {
            table.valuesX[i] = i;
            table.valuesY[i] = i;
        }
        for (int i = 1; i < ARRAYSIZE(_scaleTables); ++i) {
            _scaleTables[i] = _scaleTables[0];
        }
    }

    const CelScalerTable &getScalerTable(const Ratio &scaleX, const Ratio &scaleY);
};

#pragma mark -
#pragma mark CelObj

class ScreenItem;
class CelObj {
protected:
    static bool _drawBlackLines;

    bool _drawMirrored;

public:
    static CelScaler *_scaler;

    CelInfo32 _info;

    uint32 _celHeaderOffset;

    uint32 _hunkPaletteOffset;

    uint16 _width, _height;

    Common::Point _origin;

    uint16 _xResolution, _yResolution;

    uint8 _skipColor;

    bool _transparent;

    CelCompressionType _compressionType;

    bool _remap;

    bool _mirrorX;

    bool _isMacSource;

    static void init();

    static void deinit();

    virtual ~CelObj() {};

    void draw(Buffer &target, const ScreenItem &screenItem, const Common::Rect &targetRect) const;

    virtual void draw(Buffer &target, const ScreenItem &screenItem, const Common::Rect &targetRect, const bool mirrorX);

    virtual void draw(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition, const bool mirrorX);

    void drawTo(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition, const Ratio &scaleX, const Ratio &scaleY) const;

    virtual CelObj *duplicate() const = 0;

    virtual const SciSpan<const byte> getResPointer() const = 0;

    virtual uint8 readPixel(const uint16 x, const uint16 y, const bool mirrorX) const;

    void submitPalette() const;

#pragma mark -
#pragma mark CelObj - Drawing
private:
    template<typename MAPPER, typename SCALER>
    void render(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;

    template<typename MAPPER, typename SCALER>
    void render(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition, const Ratio &scaleX, const Ratio &scaleY) const;

    void drawHzFlip(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawNoFlip(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawUncompNoFlip(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawUncompHzFlip(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void scaleDraw(Buffer &target, const Ratio &scaleX, const Ratio &scaleY, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void scaleDrawUncomp(Buffer &target, const Ratio &scaleX, const Ratio &scaleY, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;

    void drawHzFlipMap(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawNoFlipMap(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawUncompNoFlipMap(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawUncompHzFlipMap(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void scaleDrawMap(Buffer &target, const Ratio &scaleX, const Ratio &scaleY, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void scaleDrawUncompMap(Buffer &target, const Ratio &scaleX, const Ratio &scaleY, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    // SSCI includes versions of the above functions with priority parameters
    // which are not actually used in SCI32

    void drawHzFlipNoMD(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawNoFlipNoMD(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawUncompNoFlipNoMD(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawUncompNoFlipNoMDNoSkip(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawUncompHzFlipNoMD(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void drawUncompHzFlipNoMDNoSkip(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void scaleDrawNoMD(Buffer &target, const Ratio &scaleX, const Ratio &scaleY, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    void scaleDrawUncompNoMD(Buffer &target, const Ratio &scaleX, const Ratio &scaleY, const Common::Rect &targetRect, const Common::Point &scaledPosition) const;
    // SSCI includes versions of the above functions with priority parameters
    // which are not actually used in SCI32

#pragma mark -
#pragma mark CelObj - Caching
protected:
    static int _nextCacheId;

    static CelCache *_cache;

    int searchCache(const CelInfo32 &celInfo, int *nextInsertIndex) const;

    void putCopyInCache(int index) const;
};

#pragma mark -
#pragma mark CelObjView

class CelObjView : public CelObj {
private:
    bool analyzeUncompressedForRemap() const;

    bool analyzeForRemap() const;

public:
    CelObjView(const GuiResourceId viewId, const int16 loopNo, const int16 celNo);
    ~CelObjView() override {};

    using CelObj::draw;

    static int16 getNumLoops(const GuiResourceId viewId);
    static int16 getNumCels(const GuiResourceId viewId, const int16 loopNo);

    void draw(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition, bool mirrorX, const Ratio &scaleX, const Ratio &scaleY);

    CelObjView *duplicate() const override;
    const SciSpan<const byte> getResPointer() const override;

    Common::Point getLinkPosition(const int16 linkId) const;
};

#pragma mark -
#pragma mark CelObjPic

class CelObjPic : public CelObj {
private:
    bool analyzeUncompressedForSkip() const;

public:
    uint8 _celCount;

    Common::Point _relativePosition;

    int16 _priority;

    CelObjPic(const GuiResourceId pictureId, const int16 celNo);
    ~CelObjPic() override {};

    using CelObj::draw;
    void draw(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition, const bool mirrorX) override;

    CelObjPic *duplicate() const override;
    const SciSpan<const byte> getResPointer() const override;
};

#pragma mark -
#pragma mark CelObjMem

class CelObjMem : public CelObj {
public:
    CelObjMem(const reg_t bitmap);
    ~CelObjMem() override {};

    CelObjMem *duplicate() const override;
    const SciSpan<const byte> getResPointer() const override;
};

#pragma mark -
#pragma mark CelObjColor

class CelObjColor : public CelObj {
public:
    CelObjColor(const uint8 color, const int16 width, const int16 height);
    ~CelObjColor() override {};

    using CelObj::draw;
    void draw(Buffer &target, const Common::Rect &targetRect) const;
    void draw(Buffer &target, const ScreenItem &screenItem, const Common::Rect &targetRect, const bool mirrorX) override;
    void draw(Buffer &target, const Common::Rect &targetRect, const Common::Point &scaledPosition, const bool mirrorX) override;

    CelObjColor *duplicate() const override;
    const SciSpan<const byte> getResPointer() const override;
};

} // End of namespace Sci

#endif // SCI_GRAPHICS_CELOBJ32_H