cdxsprite.h

Go to the documentation of this file.

// $Source: /cvsroot/cdx/cdx3.0/src/cdx/cdxsprite.h,v $
// $Author: mindcry $
//
// $Log: cdxsprite.h,v $
// Revision 1.11  2001/01/11 14:38:49  mindcry
// Added CountFrames, which tells you the number of frames in a CDXSprite.
//
// Revision 1.10  2000/11/29 21:37:47  wasteland
// Changed m_angle from an int to a double to match up with what is passed to CDXSurface::RotoZoom
//
// Revision 1.9  2000/09/30 19:30:08  istan
// Moved private vars to be protected instead for subclasses.
//
// Revision 1.8  2000/09/07 05:06:52  istan
// Added default value for MemoryType in Create()
//
// Revision 1.7  2000/05/31 17:47:55  hebertjo
// Added some Accessor functions
//
// Revision 1.6  2000/05/12 22:48:02  hebertjo
// I added RotoZoomimg to CDXSurface and CDXSprite.  I ripped this code from NukeDX.
// IT works and as been debuged by them but it is slow.  CDX definitely needed this
// feature and it did not take long to CDX'ize their code so I added it.  I plan
// on changing this to a faster implementation once I finish it.
//
// Revision 1.5  2000/05/10 23:29:26  hebertjo
// Cleaned up all the old code that was commented out.  Version 3.0 is getting
// very close to release.
//
// Revision 1.4  2000/05/09 01:22:06  hebertjo
// Moved the CDXBLT_XXXX #defines to cdxsurface.h.  This is where they belong, thanks
// to who ever pointed that out.
//
// Revision 1.3  2000/05/01 17:06:26  hebertjo
// Many small changes.  Fixed a few problems identified by BoundsChecker.
// Removed some old code that was commented out.  Cleaned up the look of
// some of the code.
//
// Revision 1.2  2000/04/26 18:45:43  hebertjo
// Made many small changes to fix numerous bugs and some enhancements.
//
// Revision 1.1.1.1  2000/04/22 16:12:01  hebertjo
// Initial checkin of v3.0 to SourceForge CVS.
//
// Revision 2.10  2000/03/20 21:11:23  wasteland
// Added methods to get the Position and Velocity
//
// Revision 2.9  2000/01/21 01:34:25  jhebert
// Changed m_Tile to GetTile().
//
// Revision 2.8  2000/01/13 23:43:17  jhebert
// First checkin for v3.0.  No major changes, added some safety chacks and all
// the functions have headers.
//
// 
//
// $Revision: 1.11 $
#ifndef CDXSPRITE_H
#define CDXSPRITE_H

#include "cdx.h"

// push avoid dll warning
#ifdef __WIN32__
#  pragma warning( push )
#  pragma warning( disable: 4251 )
#endif

class ARSA_API CDXSprite
{
public:
        static bool saveCache(CDXSurface* tile, bool overwrite = true );
        static CDXSurface* loadCache(const irr::io::path& filename_ext );

        CDXSprite(void);
        //CDXSprite(const char* Filename, int w, int h, int num=0);
        //CDXSprite(const char* Filename, int num = 0 );

        CDXSprite(void* pScreen, const char* Filename, int w, int h, int num, int memoryType = 0);
        virtual ~CDXSprite(void);

        virtual int Create(const char* Filename, int w, int h, int num=0);
        virtual int Create(const char* Filename, int num=0);
        virtual bool Create( int Width, int Height, int Bpp, DWORD Flags  );
        virtual bool CreateSameSrc( CDXSurface*src, int Width, int Height, DWORD Flags  );
        virtual void Destroy( );
        virtual void SetColorKey(const irr::core::vector2di& pos = irr::core::vector2di(0, 0));
        virtual void SetColorKey(const CDX_Color& color);

        virtual void SetAlpha( WORD alpha ) { return m_Pal.setAlpha(alpha); }
        virtual void SetShadow( bool Enable, const CDX_Color& color ) {  }
        virtual void SetPal( const CDX_Color& pal ) { m_Pal = pal; }

        virtual void SetOrder(irr::u32 order) { m_Order = order; }
        virtual irr::u32 GetOrder() const { return m_Order; }
        virtual void SetPos(int pX, int pY) { m_PosX = pX; m_PosY = pY; }
        virtual void SetPosX(int pX) { m_PosX = pX; }
        virtual void SetPosY(int pY) { m_PosY = pY; }
        virtual void GetPos(int &pX, int &pY) const { pX = m_PosX; pY = m_PosY; }
        virtual int  GetPosX(void) const { return m_PosX; }
        virtual int  GetPosY(void) const { return m_PosY; }
        virtual void SetVel(int vX, int vY) { m_VelX = vX; m_VelY = vY; }
        virtual void SetVelX(int vX) { m_VelX = vX; }
        virtual void SetVelY(int vY) { m_VelY = vY; }
        virtual void GetVel(int &vX, int &vY) const { vX = m_VelX; vY = m_VelY; }
        virtual int  GetVelX(void) const { return m_VelX; }
        virtual int  GetVelY(void) const { return m_VelY; }
        virtual void SetFrame(int frame) { m_Frame = frame; }
        virtual int  GetFrame(void) { return m_Frame; }
        //int  CountFrames(void) { return m_Tile->GetBlockCount(); }
        virtual void SetDelay(int delay) { m_Delay = delay; }
        virtual int  GetDelay(void) {return m_Delay;}
        virtual void SetState(int state) { m_State = state; }
        virtual int  GetState(void) {return m_State;}
        virtual void SetType(int type) { m_Type = type; }
        virtual int  GetType(void) {return m_Type;}
        virtual void SetAngle(double angle) { m_Angle = angle; }
        virtual double GetAngle(void) {return m_Angle;}
        virtual void SetScale(float scale) { m_ScaleFactor = scale; }
        virtual float GetScale(void) {return m_ScaleFactor;}
        virtual void SetShadowValue(WORD Shade) { m_ShadowValue = Shade; }
        virtual WORD GetShadowValue(void) { return m_ShadowValue; }
        virtual void SetAlphaValue(WORD Shade) { m_AlphaValue = Shade; }
        virtual WORD GetAlphaValue(void) { return m_AlphaValue; }
        virtual void SetStretchWidth(WORD width) { m_StretchedWidth = width; }
        virtual WORD GetStretchWidth(void) { return m_StretchedWidth; }
        virtual void SetStretchHeight(WORD height) { m_StretchedHeight = height; }
        virtual WORD GetStretchHeight(void) { return m_StretchedHeight; }
        virtual CDXSurface*   GetTile(void) const { return m_Tile; }
        // see E_KEY_STATE in CARSAInput.h
        virtual bool    SpriteHitTouch( int touch_flag, int ext = 10);
        virtual bool    SpriteHit( int x, int y, int ext = 10 );
        virtual bool    SpriteHit(CDXSprite* pSprite);
        virtual bool    SpriteHitPixel(CDXSprite* pSprite);
        virtual bool    IsFlipped(void) { return m_Flipped; }
        virtual int Draw(CDXSurface* lpCDXS = 0, DWORD ScrnWorldX = 0, DWORD ScrnWorldY = 0, WORD BltType = 0, PRECT rect = 0, CDX_Color* Pal = 0, bool mem_alloc = false );
        virtual int Draw(PRECT rect, CDX_Color* Pal = 0, bool mem_alloc = false);
        virtual int GetBlockWidth() { return m_BlockWidth; }
        virtual int GetBlockHeight() { return m_BlockHeight; }
        virtual int GetBlockCount() { return m_BlockNum; }
        virtual int GetWidth() { return GetBlockWidth(); }
        virtual int GetHeight() { return GetBlockHeight(); }
        virtual bool GetBoundingBox( PRECT out_rect );
        virtual const CDX_Color& GetPal() const { return m_Pal; }
        virtual const char* GetName() const;
        virtual bool isOk() const { return m_Tile ? true : false; }

        //===========================//
        // clone
        //===========================//
        virtual CDXSprite* clone(void); // MUST delete
        virtual void clone(CDXSprite* dest);

        void setDebug(int debug) { m_Debug = debug; }
        int getDebug() const { return m_Debug; }

protected:
        virtual void Init(void);

// MichaelR: Did on request so subclasses would be able to access these variables
// instead of having to use the slower accessor function, but of course at their own
// risk of them changing in later revs.
//protected:
public:
        int m_PosX;                             // The sprite's X position
        int m_PosY;                             // The sprite's Y position
        int m_PosZ;             // The sprite's Z position
        int m_VelX;                             // The sprite's X velocity
        int m_VelY;                             // The sprite's Y velocity
        int m_Frame;                    // The current frame
        int m_Delay;                    // Used for game timing, the time till the next frame
        int m_State;                    // User defined state.  Walking, jumping, etc
        int m_Type;                             // User defined type.  Health, weapon, etc
        double m_Angle;                 // The sprite's angle of rotation
        float m_ScaleFactor;    // The amount by which to scale the sprite if Drawing with CDXBLT_XXXSCALED
        bool m_Flipped;                 // Is the sprite flipped?
        LONG m_ShadowOffsetX;   // Amount to offset the shadow in the X direction
        LONG m_ShadowOffsetY;   // Amount to offset the shadow in the Y direction
        WORD m_ShadowValue;     // Alpha value used in drawing the shadow 0-256
        WORD m_AlphaValue;      // Alpha value used when alpha blending 0-256
        bool m_TileCreated;     // Used internal to determine if the class created the CDXTile object or not
        WORD m_StretchedHeight; // Used to define the height of the stretched sprite 
        WORD m_StretchedWidth;  // Used to define the width of the stretched sprite
        CDXSurface* m_Tile;             // irr::video::ITexture*, A CDXTile pointer to the sprite's bitmap data
        int m_BlockWidth;               // The width of one tile, in pixels
        int m_BlockHeight;      // The height of one tile, in pixels
        int m_BlockNum;         // The number of tiles in the bitmap file

        CDX_Color m_Pal;
        bool m_FromCache;
        int m_Debug;

        irr::u32 m_Order;
        irr::core::matrix4 m_World;
        irr::scene::SMeshBuffer m_Mb; // mesh buffer
};

// pop avoid dll warning
#ifdef __WIN32__
#  pragma warning( pop )
#endif

#endif