sdl_cvideo.cpp

Go to the documentation of this file.

#include "cvideo.h"
#include "cgame.h"
#include "cdebug.h"

#include <SDL.h>

namespace SDLDriver {
  /* Convert a CRect structure to an SDL_Rect structure. */
  void crect_to_sdl_rect(const CRect &cr, SDL_Rect &sr) {
    sr.x = cr.pos.x;
    sr.y = cr.pos.y;
    sr.w = cr.size.x;
    sr.h = cr.size.y;
  }

  /* The screen.  Due to the massive level of decoupling
     between the high-level video system manager and the
     low-level SDL implementation layers, it's just easier
     to store our own pointer to the screen and change it
     whenever the higher-level layer asks the lower-level
     layer for it to be changed.
     
     Note that this variable is at the module level; it's
     static, using internal linkage, so it's not a global
     variable, which hopefully makes it not too evil. */
  static SDL_Surface *g_screen;

class CSurfaceImplSDL : public CSurfaceImpl {
  /* The reference count of the surface (how many variables are
     currently referring to us?).  Used for basic
     garbage collection. */
  int reference_count;

  /* The actual SDL surface representing the bitmap. */
  SDL_Surface *sdl_surface;

public:
  CSurfaceImplSDL() : reference_count(0), sdl_surface(0) { }

  CSurfaceImplSDL(int w, int h) : reference_count(0)
  {
    int flags = 0;

    SDL_PixelFormat *pf = g_screen->format;
    
    sdl_surface = SDL_CreateRGBSurface(flags, w, h, pf->BitsPerPixel,
      pf->Rmask, pf->Gmask, pf->Bmask, pf->Amask);
    inc_ref_count();
  }

  CSurfaceImplSDL(const char *filename) : reference_count(0)
  {
    sdl_surface = SDL_LoadBMP(filename);
    if (!sdl_surface) {
      CDebug::log("Couldn't load BMP.\n", 1);
    }
    inc_ref_count();
  }

  virtual ~CSurfaceImplSDL() {
    /* Make sure no CSurface objects are pointing to us. */
    assert(reference_count == 0);
    /* Free our bitmap surface. */
    SDL_FreeSurface(sdl_surface);
  }

  virtual void set_transparent_color(CColor color) {
    SDL_SetColorKey(sdl_surface, SDL_SRCCOLORKEY | SDL_RLEACCEL, color);
        SDL_Surface *bitmap = SDL_DisplayFormatAlpha(sdl_surface);
    SDL_FreeSurface(sdl_surface);
    sdl_surface = bitmap;
  }

  virtual void inc_ref_count() {
    reference_count++;
  }

  virtual void dec_ref_count() {
    assert(reference_count > 0);
    reference_count--;
    printf("CSurfaceImplSDL detached: --refcount = %d (%dx%d).\n", reference_count, 
      sdl_surface->w, sdl_surface->h);
  }

  virtual int is_empty() { return (reference_count == 0); }

  virtual int get_depth() { return sdl_surface->format->BitsPerPixel; }

  virtual int get_width() { return sdl_surface->w; }

  virtual int get_height() { return sdl_surface->h; }

  virtual void blit(CSurfaceImpl &source) { SDL_BlitSurface( ((CSurfaceImplSDL *) &source)->sdl_surface, NULL, sdl_surface, NULL); }

  virtual void blit(CSurfaceImpl &source, CPoint &dest_pos) {
    SDL_Rect r;

    r.x = dest_pos.x;
    r.y = dest_pos.y;

    SDL_BlitSurface( ((CSurfaceImplSDL *) &source)->sdl_surface, NULL, sdl_surface, &r);
  }

  virtual void blit(CSurfaceImpl &source, CPoint &dest_pos, CRect &src_rect) {
    SDL_Rect r_src, r_dst;

    crect_to_sdl_rect(src_rect, r_src);

    r_dst.x = dest_pos.x;
    r_dst.y = dest_pos.y;
    
    SDL_BlitSurface( ((CSurfaceImplSDL *) &source)->sdl_surface, &r_src, sdl_surface, &r_dst);
  }

  virtual void fill_rect(const CRect &rect, CColor color) {
    SDL_Rect sdl_rect;

    crect_to_sdl_rect(rect, sdl_rect);

    SDL_FillRect( sdl_surface, &sdl_rect, color);
  }

  virtual void set_clipping_rect(CRect &rect) {
    SDL_Rect sdl_rect;

    crect_to_sdl_rect(rect, sdl_rect);

    SDL_SetClipRect(sdl_surface, &sdl_rect);
  }

  virtual void clear_clipping_rect() {
    SDL_SetClipRect(sdl_surface, NULL);
  }

  virtual void flip() {
    SDL_Flip(sdl_surface);
  }

  void update_rects(CRectList &rects) {
    int num_rects = (int) rects.size();

    SDL_Rect *sdl_rects = new SDL_Rect[num_rects];

    SDL_Rect *curr_rect = sdl_rects;

    for (CRectList::iterator i = rects.begin(); i != rects.end(); i++) {
      crect_to_sdl_rect(*i, *curr_rect);
      curr_rect++;
    }

    SDL_UpdateRects(sdl_surface, num_rects, sdl_rects);

    delete[] sdl_rects;
  }

  virtual void set_video_mode(int width, int height, int depth, int is_fullscreen)
  {
    int flags = SDL_SWSURFACE;
    int actual_depth = SDL_VideoModeOK(width, height, depth, flags);
    
    if (is_fullscreen) {
      flags = flags | SDL_FULLSCREEN;
    }
    sdl_surface = SDL_SetVideoMode(width, height, actual_depth, flags);
    if ( sdl_surface == NULL ) {
      CDebug::log("couldn't init screen.\n", 1);
    }
    g_screen = sdl_surface;
    reference_count = 1;
  }
};

class CVideoSystemSDL : CVideoSystem {
 private:
  friend class CVideoSystemFactorySDL;

  /* Reference to the display. */
  CScreen *screen;

  CVideoSystemSDL(int width, int height, int depth, int is_fullscreen) {
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0) {
      CDebug::log("couldn't init SDL.\n", 1);
    }
    CSurfaceImplSDL *impl = new CSurfaceImplSDL();
    impl->set_video_mode(width, height, depth, is_fullscreen);
    screen = new CScreen(impl);
  }

 protected:
  virtual CSurfaceImpl *make_csurface_impl(int w, int h) {
   return new CSurfaceImplSDL(w, h);
  }
  virtual CSurfaceImpl *make_csurface_impl(const char *filename) {
    return new CSurfaceImplSDL(filename);
  }
  virtual uint32 make_color(uint8 r, uint8 g, uint8 b) {
    SDL_PixelFormat *pf = g_screen->format;
    return SDL_MapRGB(pf, r, g, b);
  }

 public:
  virtual ~CVideoSystemSDL() {
    delete screen;
    SDL_Quit();
  }

  virtual CScreen &get_screen() { return *screen; }
};

class CVideoSystemFactorySDL : public CVideoSystemFactory {
  /* These instance variables hold information about how we want
     our screen to be displayed once the factory is told to create the
     actual singleton. */
  int w, h, d, is_f;
  virtual CVideoSystem *make_singleton() {
    return new CVideoSystemSDL(w, h, d, is_f);
  }
 public:
  CVideoSystemFactorySDL(int width, int height, int depth, int is_fullscreen) : 
    w(width), h(height), d(depth), is_f(is_fullscreen) { }
};

  CVideoSystemFactory *make_video_system_factory(int width, int height, int depth, int is_fullscreen) {
    return new CVideoSystemFactorySDL(width, height, depth, is_fullscreen);
  }
}

---