gelSprite.h

Go to the documentation of this file.

/*
Gel2D Game Engine - Cross-platform 2D gaming middleware
Copyright (C) 2010-2011 Mark D. Procarione

Gel2D 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.

Gel2D 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.
*/

#ifndef __GELQUAD_H__
#define __GELQUAD_H__

#include "gelObject.h"
#include "gelTimer.h"

namespace gel
{
    struct GelVert
    {
        int z;
        Gel2dVec pos;
        Gel2dVec uv;
        GelColor col;
    };

    class GelSprite : public GelObject, public GelTextureObject
    {
        public:
            GelSprite();


            GelSprite( Gel2dVec obj_size, Gel2dVec obj_pos, float obj_rot );


            void setSize( Gel2dVec size );


            void flip( int axis );


            GelColor getCol( int i = 0 ) const;

            void setCol( GelColor col, int i = -1 );

            void setRGB( float r, float g, float b, int i = -1 );

            float getAlpha( int i = 0 ) const;

            void setAlpha( float alpha, int i = -1 );

            void mapRect( const Gel2dVec &pos, const Gel2dVec &size );


            void setTexture( GelTexture *tex );


            void flipTexture( Orientation axis );


            bool isTexFlipped( Orientation axis ) const;

            GelAABB getAABB() const;

            void render();

        protected:
                        int _pointIntersect( float locx, float locy );

        public:
            GelVert v[4];

        protected:
            int xFlip;
            int yFlip;
    };

    class GelAnimSprite : public GelSprite
    {
                public:
            GelAnimSprite();


            GelAnimSprite( Gel2dVec obj_size, Gel2dVec obj_pos, int col, int row, int stframe, int endframe, int nfps );


            void setup( int col, int row, int stframe, int endframe, int nfps );


            int getMode() const { return mode; }


            void setMode( int nmode ) { mode = nmode; }


            int getFPS() const { return fps; }


            void setFPS( int nfps ) { fps = nfps; speed = 1.0f/nfps; }


            int getColumns() const { return ncolumns; }


            void setColumns( int columns ) { ncolumns = columns; }


            int getRows() const { return nrows; }


            void setRows( int rows ) { nrows = rows; }

            int  getCurFrame()     const { return curFrame; }
            void setCurFrame(int frame)  { curFrame = frame; }
            int  getStartFrame()   const { return stFrame; }
            void setStartFrame(int frame){ stFrame = frame; }
            int  getEndFrame()     const { return endFrame; }
            void setEndFrame(int frame)  { endFrame = frame; }
            int  getNumFrames()    const { return endFrame-stFrame; }


            int getPlayState() const { return playState; }


            void setPlayState( int state ) { playState = state; }


            void update();

            void render();

        private:
            void tileMapUV();

        private:
            int mode;           // play mode - fwd, rev, loop, pinpong, etc.
            int fps;            // frame rate
            int ncolumns;       // number of columns in tile animation
            int nrows;          // number of rows in tile animation
            int curFrame;       // current frame of tile animation

            GelTimer timer;     // timer - d'oh!
            double elapsedTime; // time since last animation frame update
            float speed;        // animation speed (1.0f/fps)

            int stFrame;        // start frame
            int endFrame;       // end frame

            float column;       // current column
            float row;          // current row

            bool pingpong;      // stage of pingpong
            int playState;      // play, stop, pause
        };
}

#endif // __GELQUAD_H__