qafSpriteParticleObj.h

/* 
** Qaf Framework 1.2
** June 2006
** 
** Pedro Luchini de Moraes, Public Domain - Free Lunch Code
*/

#ifndef QAF_OBJ_SPRITEPARTICLEOBJ_H
#define QAF_OBJ_SPRITEPARTICLEOBJ_H

#include "../qafGameObj.h"
#include <hgesprite.h>

namespace qaf {
    
    class SpriteParticleObj : public GameObj {
        public:
            
            SpriteParticleObj (
                const hgeSprite * sprite,
                float x, float y,
                float angle,
                float vx, float vy,
                float vr,
                float ax, float ay,
                float initialSizeX, float initialSizeY,
                float finalSizeX, float finalSizeY,
                DWORD initialColor, DWORD finalColor,
                DWORD blendMode,
                float lifetime );
            
            
            
            inline hgeSprite * getSprite () {
                return &sprite;
            }
            
            inline bool isDead () {
                return (timer >= lifetime);
            }
            
            void getPos ( float * _x, float * _y, float * _angle ) {
                if ( _x )
                    *_x = x;
                if ( _y )
                    *_y = y;
                if ( _angle )
                    *_angle = angle;
            }
            
            inline void getVel ( float * _vx, float * _vy, float * _vr ) {
                if ( _vx )
                    *_vx = vx;
                if ( _vy )
                    *_vy = vy;
                if ( _vr )
                    *_vr = vr;
            }
            
            inline DWORD getColor () {
                float timeRatio = (timer/lifetime);
    
                int newR = initialR + (int) (timeRatio * deltaR);
                int newG = initialG + (int) (timeRatio * deltaG);
                int newB = initialB + (int) (timeRatio * deltaB);
                int newA = initialA + (int) (timeRatio * deltaA);
                
                return ARGB( newA, newR, newG, newB );
            }
            
            inline DWORD getBlendMode () {
                return blendMode;
            }
            
            inline void getSize ( float * xScale, float * yScale ) {
                float timeRatio = (timer/lifetime);
                
                if ( xScale )
                    *xScale = initialSizeX + (timeRatio * (finalSizeX - initialSizeX));
                if ( yScale )
                    *yScale = initialSizeY + (timeRatio * (finalSizeY - initialSizeY));
            }
            
            inline float getAge () {
                return timer;
            }
            
            
            
            void update ( int objLayer, float dt );
            void render ( int objLayer, float scrollX, float scrollY );
            
        protected:
            hgeSprite sprite;
            float x, y, angle, vx, vy, vr, ax, ay, initialSizeX, initialSizeY, finalSizeX, finalSizeY, lifetime;
            int initialR, initialG, initialB, initialA;
            int deltaR, deltaG, deltaB, deltaA;
            DWORD blendMode;
            float timer;
    };
    
}



#endif

---