Sprite.h

#ifndef _Sprite_H_
#define _Sprite_H_

//#include "Entity2D.h"
#include "Shape.h"
#include "renderer.h"
#include "TextureManager.h"

namespace zak {

class ZAKENGINE_API Sprite;

class Frame {
        public:
                float _fU, _fV, _fUW, _fUH;
};

class ZAKENGINE_API Animation : protected SupportScriptReferences {
public:
        bool Load(char *filename);

        static bool RegisterAnimation(char *className=NULL);
        
        //Animation(int iSize);
        Animation();
        ~Animation();

        friend class Sprite;
        friend class ScriptMgr;

private:
        static void ConstructArray(vector<Animation> *self) {
                new(self) vector<Animation>();
        }

        static void ConstructArray(int length, vector<Animation> *self) {
                new(self) vector<Animation>(length);
        }

        static void DestructArray(vector<Animation> *self) {
                self->~vector();
        }


        static void Constructor(Animation *spr){
                new(spr) Animation();
        }
        static void Destructor(Animation *spr){
                spr->~Animation();
        }

        bool Load(const string &filename);

        int             _iSize;
        float   _fAnimationSpeed;
        bool    _bLoop;
        int             *_iFrameList;

        void SetSize(int iSize)
        {
                if (_iFrameList != NULL) {
                        delete [] _iFrameList;
                }
                if (iSize>0)
                        _iFrameList = new int [iSize];
                else
                        _iFrameList = NULL;
                _iSize = iSize;
        } //prevents frame array redefinition
};

class ZAKENGINE_API Sprite : public Shape {
        private:
        
        protected:
                TexVertex       _sprVertex[4];
                Texture         *_pTexture;
                float           _fUV[2];                // UV de la textura a usar
                float           _fW;                    // Ancho del tile
                float           _fH;                    // Alto del tile
                Frame           *_Frames;
                int                     _iFramesCount;
                int                     _iActualFrame;
                Animation       *_Animation;
                bool            _bAnimationRuning;
                float           _fTime;

                int                     _offsetX;
                int                     _offsetY;
                float           _offsetU;
                float           _offsetV;

                DWORD           _minFilter;
                DWORD           _magFilter;
                
                void SetUVWH(float fU, float fV, float fW, float fH); // TEMPORAL!!!!! BORRAMEEE!

                bool InitFrames(int iFramesCount, int iFrameWidth, int iFrameHeight,int iFramesCountPerWidth);
                bool Load(const char *pszImageFilename, unsigned int uiColorKey, bool persist = false, DWORD filter=2, DWORD mipFilter=2);
                bool Load(const string& filename) { return LoadIni((char*)filename.c_str()); }

                static void Constructor(Sprite *spr){
                        new(spr) Sprite();
                }
                static void Destructor(Sprite *spr){
                        spr->~Sprite();
                }

                static void ConstructArray(vector<Sprite> *self) {
                        new(self) vector<Sprite>();
                }

                static void ConstructArray(int length, vector<Sprite> *self) {
                        new(self) vector<Sprite>(length);
                }

                static void DestructArray(vector<Sprite> *self) {
                        self->~vector();
                }


        public:
                bool LoadIni(const char *iniFile);

                bool Unload();

                void SetFrame(int iFrame);

                int GetCurrentFrame(void){return _iActualFrame;}

                void SetAnimation(Animation *Animation);

                Animation *GetAnimation() { return _Animation; }

                bool IsAnimationRunning();

                virtual void Draw();

                void Update(float fTimeBetweenFrames);
/*
                bool IsColliding(Sprite *sprite) {
                        return Entity2D::IsColliding((Entity2D*) sprite);
                }

                bool IsColliding(Shape *shape) {
                        return Entity2D::IsColliding((Entity2D*) shape);
                }
*/
                static bool RegisterSprite(char *className=NULL);

        Sprite();

        ~Sprite();
};

}

#endif // _Sprite_H_

---