Hosting courtesy of Sourceforge

               

---

draw.h

Go to the documentation of this file.

//
//      Copyright (C) 2002 Robert Renaud
//
//      This program 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 2
//      of the License, or (at your option) any later version.
//
//      This program 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.
//
//      You should have received a copy of the GNU General Public License
//      along with this program; if not, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef DRAW_H_
#define DRAW_H_

#include "../Config.h"
#include "GraphicsDebug.h"
#include "ImageManager.h"
#include "../Parse/Parse.h"
#include "../Util/GeneralException.h"

#include <string>
#include <vector>

#include "SDL.h"

using namespace std;
namespace Graphics {

        class Drawable {
        public:
                virtual void draw(SDL_Surface* screen)=0;
                virtual ~Drawable() { }
        };

        class DrawableAt {
        public:
                virtual void drawAt(SDL_Surface* screen, SDL_Rect* loc)=0;
                virtual ~DrawableAt() { }
        };

        class AbstractImage : public DrawableAt {
        public:
                virtual void drawAt(SDL_Surface* screen, SDL_Rect* loc)=0;
                virtual void readFromFile(const string& filename)=0;
                virtual void setTransparency(Uint32 SDL_Flags)=0;
                virtual ~AbstractImage() { }
                virtual AbstractImage* dynCopyImage()=0;
        };
        
        class SingleFrameImage: public AbstractImage {
        public:
                SingleFrameImage();
                SingleFrameImage(const string& BMP_filename, Uint32 SDL_Flags=0);
                virtual void readFromFile(const string& BMP_filename);
                virtual void drawAt(SDL_Surface* screen, SDL_Rect* loc);
                virtual void setTransparency(Uint32 SDL_Flags);
                virtual AbstractImage* dynCopyImage();
        protected:
                SDL_Surface* image;
        };
        
        class AnimatedImage: public AbstractImage {
        public:
                AnimatedImage();
                AnimatedImage(const string& ANI_filename, Uint32 transparencyFlags=0);
                virtual void readFromFile(const string& ANI_filename);
                virtual void setTransparency(Uint32 SDL_Flags);
                virtual void drawAt(SDL_Surface* screen, SDL_Rect* loc);
                virtual AbstractImage* dynCopyImage();
        protected:
                size_t nextFrameIndex;
                size_t numFrames;
                size_t maxUpdates;
                size_t curUpdates;
                vector<SDL_Surface*> frameVec;
        };

        class ImageFrame: public DrawableAt {
        public: 
                
                ImageFrame(DrawableAt* imageToFrame, Uint32 pix = 0x3255123, Uint8 borderWidth =3);     
                ~ImageFrame();
                virtual void drawAt(SDL_Surface* screen, SDL_Rect* loc);
        private:
                DrawableAt* framedImage;
                Uint32 borderColor;
                Uint8 borderWidth;
        };

        /*      Thought about ways to get rid of this class, in favor of StdRead, but couldn't get around
        dynamic allocation problem*/
        class ReadImage: public Parse::ParseAction {
        public:
                ReadImage(AbstractImage*& imgPointer);

                virtual void getValue(std::istream &input);
        protected:
                AbstractImage*& imgPointerRef;
        };
        
        AbstractImage* dynGenerateImage(const string& filename);
        
        /*
         * The following pixel-manipulation functions are by Sam Lantinga,
         * from the documentation distributed with SDL v1.2.3.
         * ...Just putting them in here for easy access.
         *                              --Chris Peterson
         */


        Uint32 getpixel(SDL_Surface *surface, int x, int y);

        void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel);

    /*  Makes the top left pixel on a surface into its transparency key.
        Returns the pixel that was used as the colorkey.*/
        Uint32 makeTopLeftPixelTrans( SDL_Surface* lpSurface );
        
        Uint8 calcRedComp(SDL_PixelFormat* format,Uint32 pixel);
        Uint8 calcGreenComp(SDL_PixelFormat* format, Uint32 pixel);
        Uint8 calcBlueComp(SDL_PixelFormat* format, Uint32 pixel);
        
}; // namespace Graphics

#endif // ifndef DRAW_H_

---