gfx.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 NGI_GFX_H
#define NGI_GFX_H
 
#include "common/ptr.h"
 
namespace Graphics {
    struct Surface;
    class ManagedSurface;
}
 
namespace NGI {
 
class DynamicPhase;
class Movement;
struct PicAniInfo;
 
typedef Common::Point Dims;
 
struct Bitmap {
    int _x;
    int _y;
    int _width;
    int _height;
    int _type;
    int _dataSize;
    int _flags;
    int _flipping;
    Graphics::ManagedSurface *_surface;
    Graphics::ManagedSurface *_mask;
 
    Bitmap();
    Bitmap(const Bitmap &src);
    ~Bitmap();
 
    void load(Common::ReadStream *s);
    void decode(byte *pixels, const Palette &palette);
    void putDib(int x, int y, const Palette &palette, byte alpha);
    void putDibRB(byte *pixels, const Palette &palette);
    void putDibCB(byte *pixels, const Palette &palette);
 
    void convertPalette(const Palette &palette);
 
    void colorFill(uint8 *dest, uint8 *mask, byte color, int len);
    void paletteFill(uint8 *dest, uint8 *mask, byte *src, int len);
    void copier8(uint8 *dest, byte *src, int len);
    void copier16(uint16 *dest, byte *src, int len);
 
    Bitmap *reverseImage(bool flip = true) const;
    Bitmap *flipVertical() const;
 
    void drawShaded(int type, int x, int y, const Palette &palette, int alpha);
    void drawRotated(int x, int y, int angle, const Palette &palette, int alpha);
 
    bool isPixelHitAtPos(int x, int y);
 
private:
    Bitmap operator=(const Bitmap &);
};
 
class Picture : public MemoryObject {
public:
    Picture();
    ~Picture() override;
 
    void freePicture();
    void freePixelData();
 
    bool load(MfcArchive &file) override;
    void setAOIDs();
    virtual void init();
    void getDibInfo();
    const Bitmap *getPixelData();
    virtual void draw(int x, int y, int style, int angle);
    void drawRotated(int x, int y, int angle);
 
    byte getAlpha() { return (byte)_alpha; }
    void setAlpha(byte alpha) { _alpha = alpha; }
 
    Dims getDimensions() const { return Dims(_width, _height); }
    bool isPointInside(int x, int y);
    bool isPixelHitAtPos(int x, int y);
    int getPixelAtPos(int x, int y);
    int getPixelAtPosEx(int x, int y);
 
    const Bitmap *getConvertedBitmap() const { return _convertedBitmap.get(); }
    const Palette &getPaletteData() const { return _paletteData; }
    void setPaletteData(const Palette &pal);
 
    void copyMemoryObject2(Picture &src);
 
    int _x, _y;
 
protected:
    Common::Rect _rect;
    Common::ScopedPtr<Bitmap> _convertedBitmap;
    int _field_44;
    int _width;
    int _height;
    Common::ScopedPtr<Bitmap> _bitmap;
    int _field_54;
    Common::ScopedPtr<MemoryObject2> _memoryObject2;
    int _alpha;
    Palette _paletteData;
 
    void displayPicture();
};
 
class BigPicture : public Picture {
  public:
    BigPicture() {}
    ~BigPicture() override {}
 
    bool load(MfcArchive &file) override;
    void draw(int x, int y, int style, int angle) override;
};
 
class GameObject : public CObject {
  public:
    int16 _odelay;
    int _field_8;
    int16 _flags;
    int16 _id;
    Common::String _objectName;
    int _ox;
    int _oy;
    int _priority;
    int _field_20;
 
  public:
    GameObject();
    GameObject(GameObject *src);
 
    virtual Common::String toXML();
    bool load(MfcArchive &file) override;
    void setOXY(int x, int y);
    void renumPictures(Common::Array<StaticANIObject *> *lst);
    void renumPictures(Common::Array<PictureObject *> *lst);
    void setFlags(int16 flags) { _flags = flags; }
    void clearFlags() { _flags = 0; }
    Common::String getName() { return _objectName; }
 
    bool getPicAniInfo(PicAniInfo &info);
    bool setPicAniInfo(const PicAniInfo &info);
};
 
class PictureObject : public GameObject {
public:
    PictureObject();
    ~PictureObject();
 
    PictureObject(PictureObject *src);
 
    virtual bool load(MfcArchive &file, bool bigPicture);
    bool load(MfcArchive &file) override { assert(0); return false; } // Disable base class
 
    Dims getDimensions() const { return _picture->getDimensions(); }
    void draw();
    void drawAt(int x, int y);
 
    bool setPicAniInfo(const PicAniInfo &picAniInfo);
    bool isPointInside(int x, int y);
    bool isPixelHitAtPos(int x, int y);
    void setOXY2();
 
    Picture *_picture;
 
private:
    Common::Array<GameObject> _pictureObject2List;
    int _ox2;
    int _oy2;
};
 
class Background : public CObject {
public:
    Common::Array<PictureObject *> _picObjList;
 
    Common::String _bgname;
    int _x;
    int _y;
    int16 _messageQueueId;
    Palette _palette;
    Common::Array<BigPicture *> _bigPictureArray;
    uint _bigPictureXDim;
    uint _bigPictureYDim;
 
public:
    Background();
    ~Background() override;
 
    bool load(MfcArchive &file) override;
    void addPictureObject(PictureObject *pct);
 
    BigPicture *getBigPicture(int x, int y) { return _bigPictureArray[y * _bigPictureXDim + x]; }
};
 
struct ShadowsItem {
    int width;
    int height;
    DynamicPhase *dynPhase;
};
 
typedef Common::Array<ShadowsItem> ShadowsItemArray;
 
class Shadows : public CObject {
    int _sceneId;
    int _staticAniObjectId;
    int _movementId;
    ShadowsItemArray _items;
 
  public:
    Shadows();
    bool load(MfcArchive &file) override;
    void init();
 
    void initMovement(Movement *mov);
    DynamicPhase *findSize(int width, int height);
};
 
} // End of namespace NGI
 
#endif /* NGI_GFX_H */