E:/prg/sdlpp/include/sdlpp_graphics.h

#ifndef H_SDLPP_GRAPHICS
#define H_SDLPP_GRAPHICS

#include "sdlpp_common.h"

namespace SDLPP {

class Bitmap : public RefCount
{
public:
  Bitmap(const xstring& filename="");
  Bitmap(int width, int height, bool video_memory);
  Bitmap(const iVec2& size, bool video_memory);
  Bitmap(std::istream& is);
  Bitmap(ResourceFile& rf, const xstring& name);
  Bitmap(SDL_Surface* surface);
  virtual ~Bitmap();
  Bitmap(const Bitmap& rhs);
  Bitmap& operator= (const Bitmap& rhs);

  SDL_Surface* detach();

  Bitmap clone();

  void save(const xstring& filename);

  Bitmap cut(const iRect2& r);

  void draw(int x, int y);
  void draw(const iVec2& p);
  void draw(Bitmap& target, int x, int y);
  void draw(Bitmap& target, const iVec2& p) { draw(target,p.x,p.y); }

  void draw(Bitmap& target, const iRect2& src_rect, const iVec2& dest_point);

  void fill(const iRect2& r, Uint32 color);

  void fill(Uint32 color);

  iVec2   get_size() const;
  iRect2  get_rect() const { return iRect2(iVec2(0,0),get_size()); }
  int     get_width() const { return get_size().x; }
  int     get_height() const { return get_size().y; }
  int     get_bits_per_pixel() const { return m_Surface->format->BitsPerPixel; }

  Uint32  get_colorkey() const { return m_Surface->format->colorkey; }
  Uint8   get_alpha() const { return m_Surface->format->alpha; }
  void    set_pixel_32(int x, int y, Uint32 color);
  void    set_pixel_32(const iVec2& p, Uint32 color);
  Uint32  get_pixel_32(int x, int y);
  Uint32  get_pixel_32(const iVec2& p) { return get_pixel_32(p.x,p.y); }
  Uint32* get_row_32(int y);
  const Uint32* get_row_32(int y) const;

  void set_colorkey(Uint32 colorkey);
  void disable_colorkey();
  void set_alpha(Uint8 alpha);
  void disable_alpha();

  SDL_Surface* get_surface() { return m_Surface; }
  bool valid() const  { return (m_Surface!=0); }
protected:
  void destroy();
private:
  void load(const xstring& filename);
  SDL_Surface* m_Surface;
};

class BitmapLoader : public Loader<Bitmap>
{
public:
  virtual void load(Bitmap&,const xstring& name, ResourceFile* rf);
};

class BitmapCache : public Cache<Bitmap>
{
public:
  static BitmapCache* instance()
  {
    static std::auto_ptr<BitmapCache> ptr(new BitmapCache);
    return ptr.get();
  }

  static BitmapLoader& get_loader()
  {
    static BitmapLoader sl;
    return sl;
  }

private:
  friend class std::auto_ptr<BitmapCache>;
  BitmapCache() : Cache<Bitmap>(get_loader()) {}
  ~BitmapCache() {}
  BitmapCache(const BitmapCache&) : Cache<Bitmap>(get_loader()) {}
};



struct TTF_Font;

class Font
{
  TTF_Font*     m_TTF_Font;
  std::istream* m_FontStream;
  SDL_RWops*    m_RWops;

  friend class FontManager;
  Font(TTF_Font* font, std::istream* stream, SDL_RWops* rw) : m_TTF_Font(font), m_FontStream(stream), m_RWops(rw) {}
  void destroy();
public:
  //Font(const xstring& name, int point_size);
  //Font(ResourceFile& rf, const xstring& name, int point_size);
  Font() : m_TTF_Font(0), m_FontStream(0), m_RWops(0) {}
  Font(const Font& rhs) 
    : m_TTF_Font(rhs.m_TTF_Font), 
      m_FontStream(rhs.m_FontStream), 
      m_RWops(rhs.m_RWops) 
  {}
  Font& operator= (const Font& rhs) 
  { 
    m_TTF_Font=rhs.m_TTF_Font;
    m_FontStream=rhs.m_FontStream;
    m_RWops=rhs.m_RWops;
    return *this; 
  }
  virtual ~Font();

  iVec2  get_size(const xstring& text);
  Bitmap get_bitmap(const xstring& text, Uint32 color);
  iVec2  draw(int x, int y, const xstring& text, Uint32 color, int align=0);
  iVec2  draw(const iVec2& pos, const xstring& text, Uint32 color, int align=0);
  iVec2  draw(Bitmap target, int x, int y, const xstring& text, Uint32 color, int align=0);
  iVec2  draw(Bitmap target, const iVec2& pos, const xstring& text, Uint32 color, int align=0);
};

Font& get_font(const xstring& name, int point_size);
Font& get_font(ResourceFile& rf, const xstring& name, int point_size);

class GraphicsManager : public Singleton
{
public:
  static GraphicsManager* instance(bool destroy=false)
  {
    static GraphicsManager* ptr=0;
    if (!ptr && !destroy) ptr=new GraphicsManager;
    else
    if (ptr && destroy) { delete ptr; ptr=0; }
    return ptr;
  }

  virtual void shutdown() { instance(true); }

  void initialize(int width, int height, bool full_screen)
  {
    const SDL_VideoInfo* video_info=SDL_GetVideoInfo();
    if (!video_info->hw_available) m_NoFlip=true;
    Uint32 flags=SDL_ANYFORMAT|SDL_DOUBLEBUF|SDL_SWSURFACE;
    if (full_screen) flags|=SDL_FULLSCREEN;
    SDL_Surface* screen=SDL_SetVideoMode(width,height,32,flags);
    //  | SDL_OPENGL
    if (!screen) THROW("Invalid graphics format");
    m_Screen=Bitmap(screen);
  }

  void flip() 
  { 
    SDL_Flip(m_Screen.get_surface());
    if (m_NoFlip) m_Screen.fill(0);
  }

  Uint32 MapRGB(Uint8 r, Uint8 g, Uint8 b)
  {
    return SDL_MapRGB(m_Screen.get_surface()->format,r,g,b);
  }

  void GetRGB(Uint32 color, Uint8& r, Uint8& g, Uint8& b)
  {
    SDL_GetRGB(color,m_Screen.get_surface()->format,&r,&g,&b);
  }

  Bitmap& get_screen() { return m_Screen; }
private:
  GraphicsManager() : m_NoFlip(false) {}
  ~GraphicsManager()
  {
    m_Screen.detach();
  }
  GraphicsManager(const GraphicsManager&) {}

  Bitmap m_Screen;
  //SDL_Surface* m_Screen;
  bool   m_NoFlip;
};

inline Bitmap& get_screen() { return GraphicsManager::instance()->get_screen(); }
inline Uint32 MapRGB(Uint8 r, Uint8 g, Uint8 b) { return GraphicsManager::instance()->MapRGB(r,g,b); }
inline void   GetRGB(Uint32 color, Uint8& r, Uint8& g, Uint8& b) { GraphicsManager::instance()->GetRGB(color,r,g,b); }
inline void   flip() { GraphicsManager::instance()->flip(); }
Bitmap rotate(Bitmap bmp, double angle);
Bitmap recolor(Bitmap bmp, Uint32 from_color, Uint32 to_color);

} // namespace SDLPP


#endif // H_SDLPP_GRAPHICS

---