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