sprite.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 HODJNPODJ_HNPLIBS_SPRITE_H
#define HODJNPODJ_HNPLIBS_SPRITE_H

#include "bagel/hodjnpodj/globals.h"
#include "bagel/hodjnpodj/hnplibs/dibdoc.h"

namespace Bagel {
namespace HodjNPodj {

enum {
    COLOR_WHITE = RGB(255, 255, 255)
};

#define SPRITE_TOPMOST      0
#define SPRITE_FOREGROUND   64
#define SPRITE_MIDDLE       128
#define SPRITE_BACKGROUND   192
#define SPRITE_HINDMOST     255

class CSprite : public CObject {
    DECLARE_DYNCREATE(CSprite)

public:
    CSprite();  // use "new" operator to create sprites, then LoadSprite
    ~CSprite();

    CSprite *DuplicateSprite(CDC *pDC);
    bool DuplicateSprite(CDC *pDC, CSprite *pSprite);

    bool LoadSprite(CDC *pDC, const char* pszPathName);
    bool LoadSprite(CBitmap *pBitmap, CPalette *pPalette = nullptr);
    bool LoadResourceSprite(CDC *pDC, const int resId);
    bool LoadResourceSprite(CDC *pDC, const char* pszName);

    bool LoadCels(CDC *pDC, const char* pszPathName, const int nCels);
    bool LoadCels(CBitmap *pBitmap, const int nCels, CPalette *pPalette = nullptr);
    bool LoadResourceCels(CDC *pDC, const int resId, const int nCels);
    bool LoadResourceCels(CDC *pDC, const char* pszName, const int nCels);

    bool SetPalette(CPalette *pPalette);
    bool SharePalette(CPalette *pPalette);
    bool GetShared() {
        return (m_bSharedPalette);
    }

    bool PaintSprite(CDC *pDC, const int x, const int y);
    bool PaintSprite(CDC *pDC, CPoint point) {
        return (PaintSprite(pDC, point.x, point.y));
    }

    bool SetupCels(const int nCels);
    void SetCel(const int nCelID);
    void UpdateCel() {
        SetCel(m_nCelID + 1);
    }

    bool CropImage(CDC *pDC, CRect *pRect);

    bool RefreshSprite(CDC *pDC) {
        return (PaintSprite(pDC, m_cPosition.x, m_cPosition.y));
    }
    bool RefreshBackground(CDC *pDC);

    bool EraseSprite(CDC *pDC);

    void ClearBackground();

    CSprite *Interception(CDC *pDC) {
        return (Interception(pDC, m_pSpriteChain));
    }
    CSprite *Interception(CDC *pDC, CSprite * pTestSprite);
    CSprite *Interception(CRect *newRect) {
        return (Interception(newRect, m_pSpriteChain));
    }
    CSprite *Interception(CRect *newRect, CSprite * pSprite);
    bool TestInterception(CDC *pDC, CSprite * pSprite, CPoint *pPoint = nullptr);

    bool GetVisible() {
        return (m_bVisible);
    }

    void SetIntercepts(bool bValue) {
        m_bIntercepts = bValue;
    }
    bool GetIntercepts() {
        return (m_bIntercepts);
    }

    void SetPosition(int x, int y);
    void SetPosition(CPoint point) {
        SetPosition(point.x, point.y);
    }
    CPoint GetPosition() {
        return (m_cPosition);
    }

    void SetDelta(int x, int y) {
        m_cMovementDelta.x = x;
        m_cMovementDelta.y = y;
    }
    CPoint GetDelta() {
        return (m_cMovementDelta);
    }

    void SetHotspot(int x, int y) {
        m_cHotspot.x = x;
        m_cHotspot.y = y;
    }
    CPoint GetHotspot() {
        return (m_cHotspot);
    }

    CSize GetSize() {
        return (m_cSize);
    }

    CRect GetRect() {
        return (m_cRect);
    }
    CRect GetArea() {           // obsolete - use GetRect
        return (m_cRect);
    }

    void SetMasked(bool bValue) {
        m_bMasked = bValue;
    }
    bool GetMasked() {
        return (m_bMasked);
    }

    void SetMobile(bool bValue) {
        m_bMobile = bValue;
    }
    bool GetMobile() {
        return (m_bMobile);
    }

    void SetOptimizeSpeed(bool bValue) {
        m_bRetainContexts = false & bValue;
    }
    bool GetOptimizeSpeed() {
        return (m_bRetainContexts);
    }

    void SetTypeCode(int nValue) {
        m_nType = nValue;
    }
    int GetTypeCode() {
        return (m_nType);
    }

    void SetData(CObject *pData) {
        m_pData = pData;
    }
    CObject *GetData() {
        return (m_pData);
    }

    int GetId() {
        return (m_nId);
    }

    void SetZOrder(int nValue) {
        m_nZOrder = nValue;
        m_nZPosition = nValue;
    }
    int GetZOrder() {
        return (m_nZOrder);
    }
    int GetZPosition() {
        return (m_nZPosition);
    }

    int GetCelCount() {
        return (m_nCelCount);
    }
    int GetCelIndex() {
        return (m_nCelID);
    }

    void SetAnimated(bool bAnimated) {
        m_bAnimated = bAnimated;
    }
    bool GetAnimated() {
        return (m_bAnimated);
    }

    void SetRetainBackground(bool bValue);
    bool GetRetainBackground() {
        return (m_bRetainBackground);
    }

    bool IsLinked() {
        return (m_bLinked);
    }
    void LinkSprite();
    void UnlinkSprite();
    CSprite *GetNextSprite() {
        return (m_pNext);
    }
    CSprite *GetPrevSprite() {
        return (m_pPrev);
    }

    bool Touching(CPoint myPoint);

    static  CSprite *Touched(CPoint myPoint) {
        return (Touched(myPoint, m_pSpriteChain));
    }
    static  CSprite *Touched(CPoint myPoint, CSprite *pSprite);
    static  bool InterceptOccurred() {
        return (m_bTouchedSprite);
    }
    static  CSprite *GetInterception() {
        return (m_pTouchedSprite);
    }

    static  CSprite *GetSpriteChain() {
        return (m_pSpriteChain);
    }
    static  bool EraseSprites(CDC *pDC);
    static  void ClearBackgrounds();
    static  void FlushSpriteChain();

    static  bool HaveBackdrop() {
        return (m_bHaveBackdrop);
    }
    static  CDC *GetBackdropDC(CDC *pDC);
    static  void ReleaseBackdropDC();
    static  bool SetBackdrop(CDC *pDC, CPalette *pPalette, CBitmap *pBitmap);
    static  void ClearBackdrop();
    static  bool RefreshBackdrop(CDC *pDC, CPalette *pPalette);

private:
    bool UpdateSprite(CDC *pDC);

    bool SaveBackground(CDC *pDC);

    bool CreateBackground(CDC *pDC);
    bool CreateMask(CDC *pDC);

    bool SetupImage(CDC *pDC);
    bool SetupBackground(CDC *pDC);
    bool SetupMask(CDC *pDC);

    bool CreateImageContext(CDC *pDC);
    bool CreateBackgroundContext(CDC *pDC);
    bool CreateMaskContext(CDC *pDC);

    void ReleaseImageContext();
    void ReleaseBackgroundContext();
    void ReleaseMaskContext();

    void ClearImage();
    void ClearMask();
    void ClearPalette();

    bool SpritesOverlap(CDC *pDC, CSprite *pSprite, CPoint *pPoint = nullptr);

    bool DoSpritePainting(CDC *pDC, CPoint cPoint);
    bool DoOptimizedPainting(CDC *pDC, CRect *pDst);
    bool DoOverlapPainting(CDC *pDC, CRect *myRect);
    bool ReconstructBackground(CDC *pDC, CRect *myRect);

private:
    CDC         *m_pImageDC;        // offscreen bitmap device context for image
    CBitmap     *m_pImage;          // bitmap for the sprite
    CBitmap     *m_pImageOld;       // previous bitmap mapped in the DC
    CDC         *m_pMaskDC;         // offscreen bitmap device context for mask
    CBitmap     *m_pMask;           // bitmap for the sprite's mask
    CBitmap     *m_pMaskOld;        // previous bitmap mapped in the DC
    CDC         *m_pBackgroundDC;   // offscreen bitmap device context for background
    CBitmap     *m_pBackground;     // bitmap for the sprite's background
    CBitmap     *m_pBackgroundOld;  // previous bitmap mapped in the DC
    CPalette    *m_pPalette;        // color palette for the sprite
    CPalette    *m_pPalImageOld;    // previous palette mapped to image DC
    CPalette    *m_pPalBackOld;     // previous palette mapped to background DC
    CPoint      m_cPosition;        // upper left corner of sprite on display
    CPoint      m_cMovementDelta;   // dx/dy increments for sprite movement
    CPoint      m_cHotspot;         // logical hotspot; e.g. for cursors
    CSize       m_cSize;            // dx/dy size of the sprite bitmap
    CRect       m_cRect;            // bounding rectangle on display
    CRect       m_cImageRect;       // bounding rectangle within image bitmap
    bool        m_bVisible;         // sprite has an image to be painted
    bool        m_bIntercepts;      // sprite can be detected by interception
    bool        m_bSharedPalette;   // palette is shared and not deleteable
    bool        m_bMasked;          // sprite is to be masked (ignore white)
    bool        m_bMobile;          // sprite is mobile or stationary
    bool        m_bOverlaps;        // sprite covers other sprites
    bool        m_bPaintOverlap;    // whether to paint sprite for overlaps
    bool        m_bRetainBackground;// retain background for screen updates
    bool        m_bRetainContexts;  // retain device contexts across calls
    bool        m_bDuplicated;      // shares bitmaps with some other sprite
    bool        m_bOverlapTest;     // used for positional testing
    bool        m_bPositioned;      // whether sprite has been positioned yet
    bool        m_bAnimated;        // whether cel advance occurs when painting
    bool        m_bLinked;          // whether sprite is linked into the chain
    int         m_nId;              // unique sprite identifier
    int         m_nType;            // user defined information
    CObject     *m_pData;           // user defined data pointer
    int         m_nZOrder;          // foreground / background order
    int         m_nZPosition;       // foreground / background placement
    int         m_nCelID;           // index of current cel image
    int         m_nCelCount;        // number of cels in the animation strip
    CSprite     *m_pNext;           // pointer to next sprite in master chain
    CSprite     *m_pPrev;           // pointer to previous sprite in master chain
    CSprite     *m_pZNext;          // pointer to next sprite in z chain
    CSprite     *m_pZPrev;          // pointer to previous sprite in z chain

    static int      m_nIndex;           // generator of sprite identifiers
    static CSprite  *m_pSpriteChain;    // pointer to linked chain of sprites
    static bool     m_bTouchedSprite;   // set when sprite painting intercepts another
    static CSprite  *m_pTouchedSprite;  // sprite touched during painting operation
    static bool     m_bHaveBackdrop;    // whether we have a backdrop bitmap
    static CDC      *m_pBackdropDC;     // context used for backdrop artwork
    static CBitmap  *m_pBackdrop;       // pointer to backdrop bitmap for background
    static CBitmap  *m_pBackdropOld;    // bitmap previously mapped to backdrop context
    static CPalette *m_pBackdropPalette;// palette mapped to backdrop context
    static CPalette *m_pBackdropPalOld; // palette previously mapped to backdrop context
};

} // namespace HodjNPodj
} // namespace Bagel

#endif