qafCollisionStruct.h

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

#ifndef QAF_COLLISIONSTRUCT_H
#define QAF_COLLISIONSTRUCT_H   

#include <hgesprite.h>
#include "qafutil/qafContainer.h"
#include "qafutil/qafVector2D.h"


namespace qaf {
    
    class CollisionStruct {
        public:
            
            virtual bool collidesWith ( CollisionStruct * otherStruct ) = 0;
            
            virtual bool hasPoint ( float x, float y ) = 0;
            
            virtual bool pointIntersection ( float x1, float y1,
                                             float x2, float y2,
                                             Vector2D * pContact,
                                             Vector2D * pNormal ) = 0;
            
            virtual void move ( float dx, float dy ) = 0;
            
            virtual void render ( float scrollX, float scrollY, unsigned long color ) = 0;
            
            virtual ~CollisionStruct ();
            
            class Box;
            class Circle;
            class Composite;
            class Polygon;
        
        private:
            static bool collide_Box_Circle     ( Box    *pBox,  Circle  *pCirc );
            static bool collide_Box_Polygon    ( Box    *pBox,  Polygon *pPoly );
            static bool collide_Circle_Polygon ( Circle *pCirc, Polygon *pPoly );
            
            static bool collide_PolyPoints ( const Vector2D * points1, int nPoints1, const Vector2D * points2, int nPoints2 );
    };
    
    
    
    
    class CollisionStruct::Box : public CollisionStruct {
        public:
            Box ( float x, float y, float w, float h );
            
            Box ();
            
            
            inline void setX ( float _x ) {
                x = _x;
            }
            inline void setY ( float _y ) {
                y = _y;
            }
            inline void setWidth ( float _w ) {
                w = _w;
            }
            inline void setHeight ( float _h ) {
                h = _h;
            }
            
            inline float getX () {
                return x;
            }
            inline float getY () {
                return y;
            }
            inline float getWidth () {
                return w;
            }
            inline float getHeight () {
                return h;
            }
            
            void render ( float scrollX, float scrollY, unsigned long color );
            bool collidesWith ( CollisionStruct * otherStruct );
            bool hasPoint ( float x, float y );
            bool pointIntersection ( float x1, float y1,
                                     float x2, float y2,
                                     Vector2D * pContact,
                                     Vector2D * pNormal );
            void move ( float dx, float dy );
            
        private:
            float x, y, w, h;
            
            friend CollisionStruct;
            
    };
    
    
    
    
    class CollisionStruct::Circle : public CollisionStruct {
        public:
            Circle ( float xCenter, float yCenter, float radius );
            
            Circle ();
            
            inline void setXCenter ( float x ) {
                xCenter = x;
            }
            inline void setYCenter ( float y ) {
                yCenter = y;
            }
            inline void setRadius ( float r ) {
                radius = r;
            }
            
            inline float getXCenter () {
                return xCenter;
            }
            inline float getYCenter () {
                return yCenter;
            }
            inline float getRadius () {
                return radius;
            }
            
            void render ( float scrollX, float scrollY, unsigned long color );
            bool collidesWith ( CollisionStruct * otherStruct );
            bool hasPoint ( float x, float y );
            bool pointIntersection ( float x1, float y1,
                                     float x2, float y2,
                                     Vector2D * pContact,
                                     Vector2D * pNormal );
            void move ( float dx, float dy );
            
        private:
            float xCenter, yCenter, radius;
            
            friend CollisionStruct;
    };
    
    
    
    
    class CollisionStruct::Composite : public CollisionStruct, public Container<CollisionStruct*> {
        public:
            Composite ( CollisionStruct * const elems[], int nCount );
            
            Composite ();
            
            void render ( float scrollX, float scrollY, unsigned long color );
            bool collidesWith ( CollisionStruct * otherStruct );
            bool hasPoint ( float x, float y );
            bool pointIntersection ( float x1, float y1,
                                     float x2, float y2,
                                     Vector2D * pContact,
                                     Vector2D * pNormal );
            void move ( float dx, float dy );
            
        private:
            friend CollisionStruct;
    };
    
    
    
    
    class CollisionStruct::Polygon : public CollisionStruct {
        public:

            Polygon ( const Vector2D * points, int nPoints );
            Polygon ( const Container<Vector2D> & points );
            
            Polygon ( const hgeSprite * pSprite );
            
            Polygon ();
            
            

            void setPoints( const Vector2D * points, int nPoints );
            
            inline void setPoints( const Container<Vector2D> & points ) {
                setPoints( points.getData(), points.getCount() );
            }
            
            inline void getTransformedPoints ( Container<Vector2D> * points ) {
                *points = realPoints;
            }
            
            void setPosition ( float x, float y );
            
            void getPosition ( float * x, float * py );
            
            void setRotation ( float radians );
            
            float getRotation ();
            
            void setScale ( float s );
            
            void getScale ();
             
            
            
            void render ( float scrollX, float scrollY, unsigned long color );
            bool collidesWith ( CollisionStruct * otherStruct );
            bool hasPoint ( float x, float y );
            bool pointIntersection ( float x1, float y1,
                                     float x2, float y2,
                                     Vector2D * pContact,
                                     Vector2D * pNormal );
            void move ( float dx, float dy );
            
        private:
            Container<Vector2D> userPoints, realPoints;
            Vector2D pos;
            float rotation, scale;
            
            void updateRealPoints ();
            
            friend CollisionStruct;
    };
    
}


#endif

---